Safe Haskell | Safe-Inferred |
---|

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 (using bash):

`>>>`

3.0`hascal 1+2`

`>>>`

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

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

`>>>`

!1.0`hascal _1 ^ 0.5`

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

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

`>>>`

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

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

`>>>`

_darcs dist hascal.cabal Hascal.hs LICENSE Main.hs README.org Setup.hs`echo *`

That's why this might not work:

`>>>`

Error. :(`hascal 1 * 2`

But you could do this instead:

`>>>`

2`hascal 1*2`

Or, you could do:

`>>>`

2`hascal '1*2'`

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

- operators :: RealFloat t => [(Char, Complex t -> Complex t -> Complex t)]
- eval :: (Read t, RealFloat t) => [(Char, Complex t -> Complex t -> Complex t)] -> String -> Either String (Complex t)
- hascal :: (Read t, RealFloat t) => String -> Either String (Complex t)
- prettyPrint :: (Show t, RealFloat t) => Complex t -> String

# 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.

`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

:: (Read t, RealFloat t) | |

=> [(Char, Complex t -> Complex t -> Complex t)] | list of operators |

-> String | string containing term |

-> Either String (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.

# 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`

.