#line 740 "/home/travis/build/felix-lang/felix/src/packages/algebra.fdoc"

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;
fun ^ (x:t,y:t) => pow (x,y);

}

Finance and Statistics.
class Special[t] {
virtual fun erf: t -> t;
virtual fun erfc: t -> t;
}