Symbolic representation of a mathematical expression. It is an instance of the Num, Fractional, and Floating type classes, so normal Haskell expressions can be used, although the expressions are limited to using the functions defined by these type classses. The type is also an instance of the IsString type class, so symbols can be expressed as Haskell string with the OverloadedStrings extension. The structure of these values is intended to be visible.

>>> 2 :: Expression
Number 2
>>> "x" :: Expression
Symbol "x"
>>> 2 + sin "x" :: Expression
BinaryApply Add (Number 2) (UnaryApply Sin (Symbol "x"))

A somewhat more concise representation can be obtained using toHaskell:

>>> toHaskell $ 2 * "y" + sin "x"
"2 * y + sin x"

Symbolic representation for unary functions.

Symbolic representation for binary functions.

Substitute the symbols with the corresponding expressions they are mapped to. The symbols will be replaced as is; there is no special treatment if the expression they are replaced by also contains the same symbol.

>>> toHaskell $ substitute ("x" + "y") (\case "x" -> Just ("a" * "b"); "y" -> Just 4)
"a * b + 4"

Calculates the value for a mathematical expression for a given assignment of values to symbols.

For example, when \(x=5\), then \(2x+1=11\).

>>> evaluate (2 * "x" + 1) (\case "x" -> Just 5)
Just 11.0

All symbols except for "pi" in a mathematical expression must be assigned a value. Otherwise, a value cannot be computed.

>>> evaluate (2 * "x" + 1) (const Nothing)
Nothing

The symbol "pi" is always used to represent \(\pi\), and any assignment to "pi" will be ignored. For example, the following is \(\pi - \pi\), not \(100 - \pi\).

>>> evaluate ("pi" - pi) (\case "x" -> Just 100)
Just 0.0

Evaluates a mathematical expression with only operations available to Fractional values. In particular, this allows exact evaluations with Rational values. Nothing will be returned if a function not supported by all Fractional values is used by the mathematical expression.

As an exception, the (**) operator is allowed with constant integer exponents, even though (**) is not a function applicable to all Fractional types.

For example,

>>> let p = 1 / (3 * "x"**5 - 2 * "x" + 1) :: Expression
>>> fractionalEvaluate p (\case "x" -> Just (2 / 7 :: Rational))
Just (16807 % 7299)

Compare against evaluate, which cannot even use Rational computations because Rational is not an instance of the Floating type class:

>>> evaluate p (\case "x" -> Just (2 / 7 :: Double))
Just 2.3026441978353196

Returns a function based on a given expression. This requires a specification of how a symbol maps the argument to a value to be used in its place.

For example, the symbol "x" could use the argument as is as its value. I.e., "x" can be mapped to a function which maps the argument to itself.

>>> let f = toFunction ("x" ** 2 + 1) (\case "x" -> id) :: Double -> Double
>>> f 3  -- 3 ** 2 + 1
10.0
>>> f 10  -- 10 ** 2 + 1
101.0

For another example, "x" could map the first element from a tuple argument, and "y" could map the second element from the tuple argument. I.e., for a tuple argument to the function, the first element will be used as "x" and the second element will be used as "y".

>>> let m = \case "x" -> (\(x,_) -> x); "y" -> (\(_,y) -> y)
>>> let g = toFunction ("x" + 2 * "y") m :: (Double, Double) -> Double
>>> g (3,4)  -- 3 + 2 * 4
11.0
>>> g (7,1)  -- 7 + 2 * 1
9.0

Returns a function corresponding to the symbolic representation of an unary function.

>>> (getUnaryFunction Cos) pi == (cos pi :: Double)
True

Returns a function corresponding to the symbolic representation of a binary function.

>>> (getBinaryFunction Add) 2 5 == (2 + 5 :: Double)
True