Hascal

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 *
_darcs dist hascal.cabal Hascal.hs LICENSE Main.hs README.org Setup.hs

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.

Types

Just re-exporting the Complex data-type for simplicity and comfort.

data Complex a

Complex numbers are an algebraic type.

For a complex number z, abs z is a number with the magnitude of z, but oriented in the positive real direction, whereas signum z has the phase of z, but unit magnitude.

Instances

Typeable1 Complex

Eq a => Eq (Complex a)

RealFloat a => Floating (Complex a)

RealFloat a => Fractional (Complex a)

Data a => Data (Complex a)

RealFloat a => Num (Complex a)

Read a => Read (Complex a)

Show a => Show (Complex a)

Functions

Operators

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

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 'c',
• 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

eval

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)

hascal is the default evaluator:

 hascal = eval operators

Pretty Printers

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

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