# 1 Synopsis.

share/lib/std/algebra/__init__.flx

include "std/algebra/predicate"; // in logic.fdoc include "std/algebra/set"; // in algebra.fdoc include "std/algebra/container"; // in algebra.fdoc include "std/algebra/equiv"; // in algebra.fdoc include "std/algebra/partialorder"; // in algebra.fdoc include "std/algebra/totalorder"; // in algebra.fdoc include "std/algebra/sequence"; // in algebra.fdoc include "std/algebra/group"; // in algebra.fdoc include "std/algebra/ring"; // in algebra.fdoc include "std/algebra/bits"; // in algebra.fdoc include "std/algebra/integer"; // in algebra.fdoc include "std/algebra/trig"; // in algebra.fdoc include "std/algebra/real"; // in algebra.fdoc include "std/algebra/complex"; // in algebra.fdoc include "std/algebra/monad"; // in algebra.fdoc

# 2 Description.

In this section we provide abstract definitions of some basic mathematical stuctures which will be used to specify operations on numeric types.

We use polymorphic classes to do this. A class is introduced by
the `class`

keyword followed by its name, then a list
of type variables in square brackets. Then the body is
presented enclosed in curly braces.

Two kinds of specification are allowed in a polymorphic class: function definitions and assertions.

## 2.1 Functions.

There are two kinds of function definitions. A function
or procedure specified with the adjective `virtual`

may have a specialisation provided in an instance declaration.
Virtual functions may have definitions, in which case the
definition is merely a default. It can be replaced in a specialising
instance. However the definition should be taken as a semantic
specification which the specialisation should adhere too.

The set of virtual functions of a polymorphic class is known
as the *basis* of the class.

A non-virtual function can be defined in terms of virtual functions and other non-virtual functions. Non virtual functions cannot be specialised by the programmer. Instead, they are automatically specialised by the system for an instance.

## 2.2 Assertions

A polymorphic class may also contain assertions. These are function like specifications which specify semantic constraints.

An `axiom`

specifies a basic assertion, it specifies a class property in
terms of relations between the class functions. Since Felix only
supports first order assertional logic, higher order semantics
must be specified in comments.

If a class contains virtual functions with definitions, the definition is also considered as axiomatic.

The set of all axioms, including those in comments,
is known as the *assertional basis* or *semantic specification*
of the class. Additionally some reductions may be or imply an
extension of the semantic basis.

A `lemma`

is an assertion which can be derived from the semantic
specifications by logical reasoning. In particular, lemmas in
principle should be self-evident, simple and useful and able
to be deduced by an automatic theorm proving program.

A `theorem`

is a more complicated derived assertion,
which would be too hard to prove with an automatic theorem
prover. Instead, it should be derivable with a proof
assistant (such as Coq), given various unspecified
strategies, tactics and hints.

# 3 Sets.

A *set* is any type with a membership predicate \(\in\)
spelled `\in`

. You can also use function `mem`

. The parser
also maps `in`

to operator `\in`

.

We also provide a reversed form \(\owns\) spelled `\owns`

,
and negated forms \(ni\) spelled `\ni`

or `\notin`

.

Three combinators are provided as well, \(\cap\) spelled `cap`

provides intersection, \(\cup\) spelled `\cup`

provides
the usual set union, and \(\setminus\) spelled `\setminus`

the asymmetic set difference or subtraction.

Note that sets are not necessarily finite.

share/lib/std/algebra/set.flx

// note: eq is not necessarily required for a membership test // for example: string member of regexp doesn't require // string equality // Set need not be finite (example regexp again) // A list is a set, despite the duplications class Set[c,t] { fun mem (elt:t, container:c):bool => elt \(\in\) container; virtual fun \(\in\) : t * c-> bool; fun \(\owns\) (container:c, elt:t) => elt \(\in\) container; fun \(\ni\) (container:c, elt:t) => elt \(\in\) container; fun \(\notin\) (elt:t, container:c) => not (elt \(\in\) container); fun \(\cup\)[c2 with Set[c2,t]] (x:c, y:c2) => { e : t | e \(\in\) x or e \(\in\) y } ; fun \(\cap\)[c2 with Set[c2,t]] (x:c, y:c2) => { e : t | e \(\in\) x and e \(\in\) y } ; fun \(\setminus\)[c2 with Set[c2,t]] (x:c, y:c2) => { e : t | e \(\in\) x and e \(\notin\) y } ; }

# 4 Set forms.

A `set_form`

is a record type with a single
member `has_elt`

which returns true if it's argument
is intended as a member of some particular set.

We construe a set_form as a Set by providing an instance.

A set_form is basically just the membership predicate remodelled as a noun by encapsulating the predicate in a closure and thereby abstracting it.

share/lib/std/algebra/set.flx

interface set_form[T] { has_elt: T -> bool; } instance[T] Set[set_form[T], T] { fun \(\in\) (elt:T, s:set_form[T]) => s.has_elt elt; } open[T] Set[set_form[T],T]; // INVERSE image of a set under a function // For a function f: t -> t2, an element e // is in a restriction of the domain t if its // image in t2 is in the specified set. fun invimg[t,c2,t2 with Set[c2,t2]] (f:t->t2, x:c2) : set_form[t] => { e : t | (f e) \(\in\) x } ;

## 4.1 Cartesian Product of set_forms.

This uses some advanced instantiation technology
to allow you to define the cartesian product of a
sequence of sets using the infix TeX operator \(\otimes\)
which is spelled `\otimes`

. There's also a left associative
binary operator \(\times\) spelled `\times`

.

share/lib/std/algebra/set.flx

fun \(\times\)[U,V] (x:set_form[U],y:set_form[V]) => { u,v : U * V | u \(\in\) x and v \(\in\) y } ; fun \(\otimes\)[U,V] (x:set_form[U],y:set_form[V]) => { u,v : U * V | u \(\in\) x and v \(\in\) y } ; fun \(\otimes\)[U,V,W] (head:set_form[U], tail:set_form[V*W]) => { u,v,w : U * V * W | u \(\in\) head and (v,w) \(\in\) tail } ; fun \(\otimes\)[NH,OH,OT] (head:set_form[NH], tail:set_form[OH**OT]) => { h,,(oh,,ot) : NH ** (OH ** OT) | h \(\in\) head and (oh,,ot) \(\in\) tail } ;

# 5 Containers.

share/lib/std/algebra/container.flx

// roughly, a finite Set class Container [c,v] { inherit Set[c,v]; virtual fun len: c -> size; fun \(\Vert\) (x:c) => len x; virtual fun empty(x: c): bool => len x == size(0); }

# 6 Orders

## 6.1 Equivalence Relation.

An equivalence relation is a reflexive, symmetric, transitive relation. It is one of the most fundamental concepts in mathematics. One can show that for any set \(S\), for any element \(s \in S\), the subset \(\lbrack s\rbrack\) of \(S\) consisting of all elements equivalent to \(s\) are also equivalent to each other, and not equivalent to any other element outside that set.

Therefore, every equivalence relation on a set \(S\) specifies a partition of \(S\) which is a set of subsets of \(S\) known as equivalence classes, or just plain classes, such that no two classes have a common intersection, and the union of the classes spans the whole set.

In other words a partition consists of a disjoint union of subsets.

The most fundamential relation in computing which is required to be an equivalence relation is the equality operator. In particular, it allows us to have distinct encodings of a value, but still consider them equal semantically, and to provide an operational measure of that equivalence.

As a simple example, consider that the rational numbers \(1/2\) and \(2/4\) have distinct encodings but none-the-less are semantically equivalent.

An online reference on Wikibooks

share/lib/std/algebra/equiv.flx

// equality: technically, equivalence relation class Eq[t] { virtual fun == : t * t -> bool; virtual fun != (x:t,y:t):bool => not (x == y); axiom reflex(x:t): x == x; axiom sym(x:t, y:t): (x == y) == (y == x); axiom trans(x:t, y:t, z:t): x == y and y == z implies x == z; fun eq(x:t, y:t)=> x == y; fun ne(x:t, y:t)=> x != y; fun \(\ne\)(x:t, y:t)=> x != y; fun \(\neq\)(x:t, y:t)=> x != y; }

## 6.2 Partial Order

A proper partial order
\(\subset\) spelled `\subset`

is a transitive,
antisymmetric
irreflexive relation.

We also provide an improper operator \(\subseteq\)
spelled `\subseteq`

which is transitive, antisymmetric,
and reflexive, for which either the partial order
or equivalence operator `==`

applies.

The choice of operators is motivated by the canonical exemplar of subset containment relations.

share/lib/std/algebra/partialorder.flx

// partial order class Pord[t]{ inherit Eq[t]; virtual fun \(\subset\): t * t -> bool; virtual fun \(\supset\)(x:t,y:t):bool =>y \(\subset\) x; virtual fun \(\subseteq\)(x:t,y:t):bool => x \(\subset\) y or x == y; virtual fun \(\supseteq\)(x:t,y:t):bool => x \(\supset\) y or x == y; fun \(\subseteqq\)(x:t,y:t):bool => x \(\subseteq\) y; fun \(\supseteqq\)(x:t,y:t):bool => x \(\supseteq\) y; fun \(\nsubseteq\)(x:t,y:t):bool => not (x \(\subseteq\) y); fun \(\nsupseteq\)(x:t,y:t):bool => not (x \(\supseteq\) y); fun \(\nsubseteqq\)(x:t,y:t):bool => not (x \(\subseteq\) y); fun \(\nsupseteqq\)(x:t,y:t):bool => not (x \(\supseteq\) y); fun \(\supsetneq\)(x:t,y:t):bool => x \(\supset\) y; fun \(\supsetneqq\)(x:t,y:t):bool => x \(\supset\) y; fun \(\supsetneq\)(x:t,y:t):bool => x \(\supset\) y; fun \(\supsetneqq\)(x:t,y:t):bool => x \(\supset\) y; axiom trans(x:t, y:t, z:t): \(\subset\)(x,y) and \(\subset\)(y,z) implies \(\subset\)(x,z); axiom antisym(x:t, y:t): \(\subset\)(x,y) or \(\subset\)(y,x) or x == y; axiom reflex(x:t, y:t): \(\subseteq\)(x,y) and \(\subseteq\)(y,x) implies x == y; }

## 6.3 Bounded Partial Order

A partial order may bave an upper or lower bound known as the supremum and infimum, respectively. If these values are in the type, they are called the maximum and minimum, respectively.

share/lib/std/algebra/partialorder.flx

class UpperBoundPartialOrder[T] { inherit Pord[T]; virtual fun upperbound: 1 -> T; } class LowerBoundPartialOrder[T] { inherit Pord[T]; virtual fun lowerbound: 1 -> T; } class BoundPartialOrder[T] { inherit LowerBoundPartialOrder[T]; inherit UpperBoundPartialOrder[T]; }

## 6.4 Total Order

A total order is a partial order with a totality law.

However we do not derive it from our partial order because we use different comparison operators. Here we use the standard ascii art comparison operators commonly found in programming languages along with the more beautiful TeX operators used in mathematical papers.

The spelling of the TeX operators can be found by holding the mouse over the symbol briefly.

share/lib/std/algebra/totalorder.flx

// total order class Tord[t]{ inherit Eq[t]; // defined in terms of <, argument order swap, and boolean negation // less virtual fun < : t * t -> bool; fun lt (x:t,y:t): bool=> x < y; fun \(\lt\) (x:t,y:t): bool=> x < y; fun \(\lneq\) (x:t,y:t): bool=> x < y; fun \(\lneqq\) (x:t,y:t): bool=> x < y; axiom trans(x:t, y:t, z:t): x < y and y < z implies x < z; axiom antisym(x:t, y:t): x < y or y < x or x == y; axiom reflex(x:t, y:t): x < y and y <= x implies x == y; axiom totality(x:t, y:t): x <= y or y <= x; // greater fun >(x:t,y:t):bool => y < x; fun gt(x:t,y:t):bool => y < x; fun \(\gt\)(x:t,y:t):bool => y < x; fun \(\gneq\)(x:t,y:t):bool => y < x; fun \(\gneqq\)(x:t,y:t):bool => y < x; // less equal fun <= (x:t,y:t):bool => not (y < x); fun le (x:t,y:t):bool => not (y < x); fun \(\le\) (x:t,y:t):bool => not (y < x); fun \(\leq\) (x:t,y:t):bool => not (y < x); fun \(\leqq\) (x:t,y:t):bool => not (y < x); fun \(\leqslant\) (x:t,y:t):bool => not (y < x); // greater equal fun >= (x:t,y:t):bool => not (x < y); fun ge (x:t,y:t):bool => not (x < y); fun \(\ge\) (x:t,y:t):bool => not (x < y); fun \(\geq\) (x:t,y:t):bool => not (x < y); fun \(\geqq\) (x:t,y:t):bool => not (x < y); fun \(\geqslant\) (x:t,y:t):bool => not (x < y); // negated, strike-through fun \(\ngtr\) (x:t,y:t):bool => not (x < y); fun \(\nless\) (x:t,y:t):bool => not (x < y); fun \(\ngeq\) (x:t,y:t):bool => x < y; fun \(\ngeqq\) (x:t,y:t):bool => x < y; fun \(\ngeqslant\) (x:t,y:t):bool => x < y; fun \(\nleq\) (x:t,y:t):bool => not (x <= y); fun \(\nleqq\) (x:t,y:t):bool => not (x <= y); fun \(\nleqslant\) (x:t,y:t):bool => not (x <= y); // maxima and minima fun max(x:t,y:t):t=> if x < y then y else x endif; fun \(\vee\)(x:t,y:t) => max (x,y); fun min(x:t,y:t):t => if x < y then x else y endif; fun \(\wedge\)(x:t,y:t):t => min (x,y); }

## 6.5 Bounded Total Orders.

share/lib/std/algebra/totalorder.flx

class UpperBoundTotalOrder[T] { inherit Tord[T]; virtual fun maxval: 1 -> T = "::std::numeric_limits<?1>::max()"; } class LowerBoundTotalOrder[T] { inherit Tord[T]; virtual fun minval: 1 -> T = "::std::numeric_limits<?1>::min()"; } class BoundTotalOrder[T] { inherit LowerBoundTotalOrder[T]; inherit UpperBoundTotalOrder[T]; }

## 6.6 Sequences

Sequences are discrete total orders.

share/lib/std/algebra/sequence.flx

// Forward iterable class ForwardSequence[T] { inherit Tord[T]; virtual fun succ: T -> T; virtual proc pre_incr: &T; virtual proc post_incr: &T; } // Bidirectional class BidirectionalSequence[T] { inherit ForwardSequence[T]; virtual fun pred: T -> T; virtual proc pre_decr: &T; virtual proc post_decr: &T; } // Bounded Random access totally ordered // int should be any integer type really .. fix later class RandomSequence[T] { inherit BidirectionalSequence[T]; virtual fun advance : int * T -> T; } // Bounded totally ordered forward iterable class BoundForwardSequence[T] { inherit ForwardSequence[T]; inherit UpperBoundTotalOrder[T]; } // Bounded totally ordered bidirectional class BoundBidirectionalSequence[T] { inherit BidirectionalSequence[T]; inherit BoundTotalOrder[T]; } // Bounded Random access totally ordered class BoundRandomSequence[T] { inherit RandomSequence[T]; inherit BoundBidirectionalSequence[T]; }

# 7 Groupoids.

## 7.1 Approximate Additive Group

An approximate additive group is a type for which there is a symmetric binary addition operator, a zero element, and for which there is an additive inverse or negation operator.

It is basically an additive group without the associativity requirement, and is intended to apply to floating point numbers.

Note we use the `inherit`

statement to include
the functions from class `Eq`

.

share/lib/std/algebra/group.flx

Additive symmetric float-approximate group, symbol +. Note: associativity is not assumed. class FloatAddgrp[t] { inherit Eq[t]; virtual fun zero: unit -> t; virtual fun + : t * t -> t; virtual fun neg : t -> t; virtual fun prefix_plus : t -> t = "$1"; virtual fun - (x:t,y:t):t => x + -y; virtual proc += (px:&t,y:t) { px <- *px + y; } virtual proc -= (px:&t,y:t) { px <- *px - y; } reduce id (x:t): x+zero() => x; reduce id (x:t): zero()+x => x; reduce inv(x:t): x - x => zero(); reduce inv(x:t): - (-x) => x; axiom sym (x:t,y:t): x+y == y+x; fun add(x:t,y:t)=> x + y; fun plus(x:t)=> +x; fun sub(x:t,y:t)=> x - y; proc pluseq(px:&t, y:t) { += (px,y); } proc minuseq(px:&t, y:t) { -= (px,y); } }

## 7.2 Additive Group

A proper additive group is derived from `FloatAddgrp`

with associativity added.

share/lib/std/algebra/group.flx

Additive symmetric group, symbol +. class Addgrp[t] { inherit FloatAddgrp[t]; axiom assoc (x:t,y:t,z:t): (x + y) + z == x + (y + z); reduce inv(x:t,y:t): x + y - y => x; }

## 7.3 Approximate Multiplicative Semi-Group With Unit.

An approximate multiplicative semigroup is a set with a symmetric binary multiplication operator and a unit.

share/lib/std/algebra/group.flx

Multiplicative symmetric float-approximate semi group with unit symbol *. Note: associativity is not assumed. class FloatMultSemi1[t] { inherit Eq[t]; proc muleq(px:&t, y:t) { *= (px,y); } fun mul(x:t, y:t) => x * y; fun sqr(x:t) => x * x; fun cube(x:t) => x * x * x; virtual fun one: unit -> t; virtual fun * : t * t -> t; virtual proc *= (px:&t, y:t) { px <- *px * y; } reduce id (x:t): x*one() => x; reduce id (x:t): one()*x => x; }

## 7.4 Multiplicative Semi-Group With Unit.

A multiplicative semigroup with unit is an approximate multiplicative semigroup with unit and associativity and satisfies the cancellation law.

share/lib/std/algebra/group.flx

Multiplicative semi group with unit. class MultSemi1[t] { inherit FloatMultSemi1[t]; axiom assoc (x:t,y:t,z:t): (x * y) * z == x * (y * z); reduce cancel (x:t,y:t,z:t): x * z == y * z => x == y; }

# 8 Rings

## 8.1 Approximate Unit Ring.

An approximate ring is a set which has addition and multiplication satisfying the rules for approximate additive group and multiplicative semigroup respectively.

share/lib/std/algebra/ring.flx

Float-approximate ring. class FloatRing[t] { inherit FloatAddgrp[t]; inherit FloatMultSemi1[t]; }

## 8.2 Ring

A ring is a type which is a both an additive group and multiplicative semigroup with unit, and which in addition satisfies the distributive law.

share/lib/std/algebra/ring.flx

Ring. class Ring[t] { inherit Addgrp[t]; inherit MultSemi1[t]; axiom distrib (x:t,y:t,z:t): x * ( y + z) == x * y + x * z; }

## 8.3 Approximate Division Ring

An approximate division ring is an approximate ring with unit with a division operator.

share/lib/std/algebra/ring.flx

Float-approximate division ring. class FloatDring[t] { inherit FloatRing[t]; virtual fun / : t * t -> t; // pre t != 0 fun \(\over\) (x:t,y:t) => x / y; virtual proc /= : &t * t; virtual fun % : t * t -> t; virtual proc %= : &t * t; fun div(x:t, y:t) => x / y; fun mod(x:t, y:t) => x % y; fun \(\bmod\)(x:t, y:t) => x % y; fun recip (x:t) => #one / x; proc diveq(px:&t, y:t) { /= (px,y); } proc modeq(px:&t, y:t) { %= (px,y); } }

## 8.4 Division Ring

share/lib/std/algebra/ring.flx

Division ring. class Dring[t] { inherit Ring[t]; inherit FloatDring[t]; }

# 9 Integral.

## 9.1 Bitwise operations

share/lib/std/algebra/bits.flx

Bitwise operators. class Bits[t] { virtual fun \^ : t * t -> t = "(?1)($1^$2)"; virtual fun \| : t * t -> t = "$1|$2"; virtual fun \& : t * t -> t = "$1&$2"; virtual fun ~: t -> t = "(?1)(~$1)"; virtual proc ^= : &t * t = "*$1^=$2;"; virtual proc |= : &t * t = "*$1|=$2;"; virtual proc &= : &t * t = "*$1&=$2;"; fun bxor(x:t,y:t)=> x \^ y; fun bor(x:t,y:t)=> x \| y; fun band(x:t,y:t)=> x \& y; fun bnot(x:t)=> ~ x; }

## 9.2 Integer

share/lib/std/algebra/integer.flx

Integers. class Integer[t] { inherit Tord[t]; inherit Dring[t]; inherit RandomSequence[t]; virtual fun << : t * t -> t = "$1<<$2"; virtual fun >> : t * t -> t = "$1>>$2"; virtual proc <<= : &t * t = "*$1<<=$2;"; virtual proc >>= : &t * t = "*$1>>=$2;"; fun shl(x:t,y:t)=> x << y; fun shr(x:t,y:t)=> x >> y; } Signed Integers. class Signed_integer[t] { inherit Integer[t]; virtual fun sgn: t -> int; virtual fun abs: t -> t; } Unsigned Integers. class Unsigned_integer[t] { inherit Integer[t]; inherit Bits[t]; }

# 10 Float kinds

## 10.1 Trigonometric Functions.

Trigonometric functions are shared by real and complex numbers.

share/lib/std/algebra/trig.flx

Float-approximate trigonometric functions. class Trig[t] { inherit FloatDring[t]; // NOTE: most of the axioms here WILL FAIL because they require // exact equality, but they're only going to succeed with approximate // equality, whatever that means. This needs to be fixed! // circular // ref http://en.wikipedia.org/wiki/Circular_functions // core trig virtual fun sin: t -> t; fun \(\sin\) (x:t)=> sin x; virtual fun cos: t -> t; fun \(\cos\) (x:t)=> cos x; virtual fun tan (x:t)=> sin x / cos x; fun \(\tan\) (x:t)=> tan x; // reciprocals virtual fun sec (x:t)=> recip (cos x); fun \(\sec\) (x:t)=> sec x; virtual fun csc (x:t)=> recip (sin x); fun \(\csc\) (x:t)=> csc x; virtual fun cot (x:t)=> recip (tan x); fun \(\cot\) (x:t)=> cot x; // inverses virtual fun asin: t -> t; fun \(\arcsin\) (x:t) => asin x; virtual fun acos: t -> t; fun \(\arccos\) (x:t) => acos x; virtual fun atan: t -> t; fun \(\arctan\) (x:t) => atan x; virtual fun asec (x:t) => acos ( recip x); virtual fun acsc (x:t) => asin ( recip x); virtual fun acot (x:t) => atan ( recip x); // hyperbolic // ref http://en.wikipedia.org/wiki/Hyperbolic_functions virtual fun sinh: t -> t; fun \(\sinh\) (x:t) => sinh x; virtual fun cosh: t -> t; fun \(\cosh\) (x:t) => cosh x; virtual fun tanh (x:t) => sinh x / cosh x; fun \(\tanh\) (x:t) => tanh x; // reciprocals virtual fun sech (x:t) => recip (cosh x); fun \(\sech\) (x:t) => sech x; virtual fun csch (x:t) => recip (sinh x); fun \(\csch\) (x:t) => csch x; virtual fun coth (x:t) => recip (tanh x); fun \(\coth\) (x:t) => coth x; // inverses virtual fun asinh: t -> t; virtual fun acosh: t -> t; virtual fun atanh: t -> t; virtual fun asech (x:t) => acosh ( recip x); virtual fun acsch (x:t) => asinh ( recip x ); virtual fun acoth (x:t) => atanh ( recip x ); // exponential virtual fun exp: t -> t; fun \(\exp\) (x:t) => exp x; // log virtual fun log: t -> t; fun \(\log\) (x:t) => log x; fun ln (x:t) => log x; fun \(\ln\) (x:t) => log x; // power virtual fun pow: t * t -> t; virtual fun pow (a:t, b:int) : t => pow (a, C_hack::cast[t] b); fun ^ (x:t,y:t) => pow (x,y); fun ^ (x:t,y:int) => pow (x,y); } Finance and Statistics. class Special[t] { virtual fun erf: t -> t; virtual fun erfc: t -> t; }

## 10.2 Approximate Reals.

share/lib/std/algebra/real.flx

Float-approximate real numbers. class Real[t] { inherit Tord[t]; inherit Trig[t]; inherit Special[t]; virtual fun embed: int -> t; virtual fun log10: t -> t; virtual fun abs: t -> t; virtual fun sqrt: t -> t; fun \(\sqrt\) (x:t) => sqrt x; virtual fun ceil: t -> t; // tex \lceil \rceil defined in grammar virtual fun floor: t -> t; // tex \lfloor \rfloor defined in grammar virtual fun trunc: t -> t; // this trig function is included here because it // is not available for complex numbers virtual fun atan2: t * t -> t; }

## 10.3 Complex numbers

share/lib/std/algebra/complex.flx

Float-approximate Complex. class Complex[t,r] { inherit Eq[t]; inherit Special[t]; inherit Trig[t]; virtual fun real: t -> r; virtual fun imag: t -> r; virtual fun abs: t -> r; virtual fun arg: t -> r; virtual fun sqrt: t -> r; virtual fun + : r * t -> t; virtual fun + : t * r -> t; virtual fun - : r * t -> t; virtual fun - : t * r -> t; virtual fun * : t * r -> t; virtual fun * : r * t -> t; virtual fun / : t * r -> t; virtual fun / : r * t -> t; }

# 11 Summation and Product Quantifiers.

To be moved. Folds over streams.

share/lib/std/algebra/group.flx

open class Quantifiers_add_mul { fun \(\sum\)[T,C with FloatAddgrp[T], Streamable[C,T]] (a:C):T = { var init = #zero[T]; for x in a perform init = init + x; return init; } fun \(\prod\)[T,C with FloatMultSemi1[T], Streamable[C,T]] (a:C):T = { var init = #one[T]; for x in a perform init = init * x; return init; } fun \(\sum\)[T with FloatAddgrp[T]] (f:1->opt[T]) = { var init = #zero[T]; for x in f perform init = init + x; return init; } fun \(\prod\)[T with FloatMultSemi1[T]] (f:1->opt[T]) = { var init = #one[T]; for x in f perform init = init * x; return init; } }

# 12 Monad

share/lib/std/algebra/monad.flx

class Monad [M: TYPE->TYPE] { virtual fun ret[a]: a -> M a; virtual fun bind[a,b]: M a * (a -> M b) -> M b; fun join[a] (n: M (M a)): M a => bind (n , (fun (x:M a):M a=>x)); }