hascal-1.4.1: A minimalistic but extensible and precise calculator

Hascal

Contents

Description

Hascal is both a simple but extendable calculator library for Haskell and a command-line program using it.

Also, its source code is a nice example for a minimalistic Haskell project.

Some examples for the usage of the command-line program:

````>>> ````hascal 1+2
```3.0
```
````>>> ````hascal 1+2*3-4/198^2
```6.99989796959493929190898887868584838281807978777676
```

Also, preceding exclamation marks mean that the following number is imaginary, that is, you have to multiply it with i. E.g.:

````>>> ````hascal _1 ^ 0.5
```!1.0
```

And as you can see, negative numbers are preceded by a underscore.

Although hascal itself doesn't understand brackets, you can use your shell to get that functionality, like this (using bash):

````>>> ````hascal e ^ \$(hascal i*pi)
```-1.0
```

Speaking of shells, you should consider that your shell might extend an asterisk (*) to the files at the current directory, like here:

````>>> ````echo *
```

That's why this might not work:

````>>> ````hascal 1 * 2
```Error. :(
```

But you could do this instead:

````>>> ````hascal 1*2
```2
```

Yeah, that's it. Hascal is really minimalistic. And I'm not planning to extend it much.

Synopsis

# Operators

operators :: RealFloat t => [(Char, Complex t -> Complex t -> Complex t)]Source

`operators` is the default list of operators.

An operator consists of one character and a function with of type `Number -> Number -> Number`.

`operators` includes:

• addition, represented by `'+'`,
• subtraction, represented by `'-'`,
• multiplication, represented by `'*'`,
• division, represented by `'/'`,
• exponentiation, represented by `'^'`, and
• logarithming (with flipped arguments, see below), represented by `'?'`,

such that these laws are held:

``` (a - b == c) == (a == b + c)
(a / b == c) == (a == b * c)
(a ? b == c) == (a == b ^ c)
```

# Evaluators

Arguments

 :: (Read t, RealFloat t) => [(Char, Complex t -> Complex t -> Complex t)] list of operators -> String string containing term -> Maybe (Complex t) just result, or nothing

`eval` gets a list of operators and a string containing a mathematical expression/term which only uses those operators listed in the first argument, and returns the result of that term.

hascal :: (Read t, RealFloat t) => String -> Maybe (Complex t)Source

`hascal` is the default evaluator:

` hascal = `eval` `operators``

# Pretty Printers

prettyPrint :: (Show t, RealFloat t) => Complex t -> StringSource

`prettyPrint` prints a number nicely. E.g., it doesn't show the real or imaginary part of the number if it's `0`.