(*----------------------------------------------------------------------*)
(*									*)
(* 				MathLib.mod				*)
(*									*)
(*----------------------------------------------------------------------*)
(* Matheroutinen							*)
(*----------------------------------------------------------------------*)
(* 	(c) 1990							*)
(*      Ingo Schuetze							*)
(*	Grabenstrasse 29						*)
(*	6301 Biebertal							*)
(*	06409/2882							*)
(*----------------------------------------------------------------------*)

(*----------------------------------------------------------------------*)
(* Mathefunktionen in mehreren Zahlendarstellungen                      *)
(*                                                                      *)
(* Der Vorteil dieses Moduls liegt darin, nach einer neuen Wahl eines   *)
(* REAL Datentyps nicht alle eigenen Module aendern zu muessen. Statt   *)
(* dessen muessen sie nur neu compiliert werden. So kann man dann       *)
(* einfacher die Unterschiede der einzelnen Librarys feststellen.       *)
(* Mit einem Vorteil ergibt sich zumeist auch ein Nachteil:             *)
(*   es muss ein Sprung mehr ausgefuehrt werden.                        *)
(*                                                                      *)
(* Man koennte es noch einfacher machen, indem man zulaesst, waehrend   *)
(* der Laufzeit ein REAL Format zu waehlen. Dann aber muesste man hier  *)
(* alle Mathe-Module einbinden, was dieses Modul unnötig lang machen    *)
(* wuerde.                                                              *)
(*                                                                      *)
(*----------------------------------------------------------------------*)
IMPLEMENTATION MODULE MathLib;

IMPORT
	(* MathLib0; *)		(* M2Amiga REAL Modul			*)
	(* MathTrans; *)	(* AMIGA FFP Zahlen			*)
	(* MathLibLong; *)	(* LONGREAL Modul			*)
	MathIEEEDoubTrans;	(* LONGREAL-68881 Modul			*)


IMPORT RandomNumber;


PROCEDURE Makepis();
BEGIN
  pi180:=pi / 180.0;
  twopi:=2.0 * pi;
  pi2:=pi / 2.0;
END Makepis;

(*----------------------------------------------------------------------*)
(*                                                                      *)
(* MathIEEEDoubTrans; LONGREAL für 68882, bzw 68881                     *)
(*                                                                      *)
(*----------------------------------------------------------------------*)

PROCEDURE InstallPiAndE;
BEGIN
  pi:=3.14159265358979323846;
   e:=2.71828182845904523536;
  Makepis;
END InstallPiAndE;

PROCEDURE sqrt(		x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Sqrt(x)
END sqrt;


PROCEDURE exp(		x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Exp(x)
END exp;


PROCEDURE ln(		x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Log(x)
END ln;


PROCEDURE sin(		x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Sin(x)
END sin;


PROCEDURE cos(		x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Cos(x)
END cos;


PROCEDURE arctan(	x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Atan(x)
END arctan;


PROCEDURE arcsin(	x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Asin(x)
END arcsin;

PROCEDURE arccos(	x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Acos(x)
END arccos;

PROCEDURE cosh(		x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Cosh(x)
END cosh;

PROCEDURE sinh(		x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Sinh(x)
END sinh;

PROCEDURE tanh(		x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Tanh(x)
END tanh;

PROCEDURE tan(		x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Tan(x)
END tan;

PROCEDURE log10(	x : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Log10(x)
END log10;

PROCEDURE pow(	base, ex  : REAL) : REAL;
BEGIN
  RETURN MathIEEEDoubTrans.Pow(base, ex)
END pow;

PROCEDURE sqr(		x : REAL) : REAL;
BEGIN
  RETURN pow(x,2.0)
END sqr;

PROCEDURE sincos(	x : REAL) : REAL;
BEGIN
END sincos;

(*-----------------------------------------------------------------------*)
(*                                                                       *)
(* MaththLibLong; LONGREAL                                               *)
(*                                                                       *)
(*-----------------------------------------------------------------------*)
(*
PROCEDURE InstallPiAndE;
BEGIN
  pi:=MathLibLong.pi;
  e:=MathLibLong.e;
  Makepis;
END InstallPiAndE;

PROCEDURE sqrt(		x : REAL) : REAL;
BEGIN
  RETURN MathLibLong.sqrt(x)
END sqrt;


PROCEDURE exp(		x : REAL) : REAL;
BEGIN
  RETURN MathLibLong.exp(x)
END exp;


PROCEDURE ln(		x : REAL) : REAL;
BEGIN
  RETURN MathLibLong.ln(x)
END ln;


PROCEDURE sin(		x : REAL) : REAL;
BEGIN
  RETURN MathLibLong.sin(x)
END sin;


PROCEDURE cos(		x : REAL) : REAL;
BEGIN
  RETURN MathLibLong.cos(x)
END cos;


PROCEDURE arctan(	x : REAL) : REAL;
BEGIN
  RETURN MathLibLong.arctan(x)
END arctan;

*)
(*-------------------------------------------------------------------------*)
(*                                                                         *)
(* MathLibFFP, beim M2Amiga auch MathTrans, FFP                            *)
(* Nicht vergessen, Random zu aendern!                                     *)
(*                                                                         *)
(*-------------------------------------------------------------------------*)
(*

PROCEDURE InstallPiAndE;
BEGIN
  pi:=3.1415926536;
  e:=2.7182818284;
  Makepis;
END InstallPiAndE;

PROCEDURE sqrt(		x : REAL) : REAL;
BEGIN
  RETURN MathTrans.Sqrt(x)
END sqrt;


PROCEDURE exp(		x : REAL) : REAL;
BEGIN
  RETURN MathTrans.Exp(x)
END exp;


PROCEDURE ln(		x : REAL) : REAL;
BEGIN
  RETURN MathTrans.Log(x)
END ln;


PROCEDURE sin(		x : REAL) : REAL;
BEGIN
  RETURN MathTrans.Sin(x)
END sin;


PROCEDURE cos(		x : REAL) : REAL;
BEGIN
  RETURN MathTrans.Cos(x)
END cos;


PROCEDURE arctan(	x : REAL) : REAL;
BEGIN
  RETURN MathTrans.Atan(x)
END arctan;

*)

(*-------------------------------------------------------------------------*)
(*                                                                         *)
(* MathLib0; REAL                                                          *)
(* sollte nur zum portieren verwendet werden, da sehr ungenau.             *)
(*                                                                         *)
(*-------------------------------------------------------------------------*)
(*

PROCEDURE InstallPiAndE;
BEGIN
  pi:=MathLib0.pi;
  e:=MathLib0.e;
  Makepis;
END InstallPiAndE;

PROCEDURE sqrt(		x : REAL) : REAL;
BEGIN
  RETURN MathLib0.sqrt(x)
END sqrt;


PROCEDURE exp(		x : REAL) : REAL;
BEGIN
  RETURN MathLib0.exp(x)
END exp;


PROCEDURE ln(		x : REAL) : REAL;
BEGIN
  RETURN MathLib0.ln(x)
END ln;


PROCEDURE sin(		x : REAL) : REAL;
BEGIN
  RETURN MathLib0.sin(x)
END sin;


PROCEDURE cos(		x : REAL) : REAL;
BEGIN
  RETURN MathLib0.cos(x)
END cos;


PROCEDURE arctan(	x : REAL) : REAL;
BEGIN
  RETURN MathLib0.arctan(x)
END arctan;

*)

(*------------------------------------------------------------------------*)
(*                                                                        *)
(* zusaetzlich :                                                          *)
(* Wegen Coprozessor abgeschaltet. Dieser kennt die folgenden Fkt intern  *)
(*                                                                        *)
(*------------------------------------------------------------------------*)
(* Man beachte, daß hier keine Sicherheitsvorkehrungen getroffen sind !!! *)
(*------------------------------------------------------------------------*)
(*

PROCEDURE tan(		x : REAL) : REAL;
BEGIN
  RETURN sin(x) / cos(x)
END tan;


PROCEDURE sqr(		x : REAL) : REAL;
BEGIN
  RETURN x * x
END sqr;


PROCEDURE arcsin(	x : REAL) : REAL;
BEGIN
  RETURN 1.0 / sin(x)
END arcsin;

PROCEDURE arccos(	x : REAL) : REAL;
BEGIN
  RETURN 1.0 / cos(x)
END arccos;

PROCEDURE cosh(		x : REAL) : REAL;
BEGIN
  RETURN (exp(x)+exp(-x)) / 2.0
END cosh;

PROCEDURE sinh(		x : REAL) : REAL;
BEGIN
  RETURN (exp(x)-exp(-x)) / 2.0
END sinh;

PROCEDURE tanh(	x : REAL) : REAL;
VAR ep, em : REAL;
BEGIN
  ep:=exp(x); em:=exp(-x);
  RETURN (ep-em) / (ep+em)
END tanh;

PROCEDURE log10(	x : REAL) : REAL;
BEGIN
  RETURN ln(x) / ln(10.0)
END log10;

PROCEDURE pow(	base, ex  : REAL) : REAL;
BEGIN
  RETURN exp(ex * ln(base))
END pow;

*)
(*------------------------------------------------------------------------*)
(*                                                                        *)
(* Random Funktionen                                                      *)
(* Falls FFP eingestellt ist, muß in Random ein Typentransfer             *)
(* durchgeführt werden, deshalb das zweite in Bemerkung		          *)
(*                                                                        *)
(*------------------------------------------------------------------------*)

(**)
PROCEDURE Random() : REAL;		(* fuer REAL, LONGREAL *)
BEGIN
  RETURN RandomNumber.Random()
END Random;
(**)

(*
PROCEDURE Random() : REAL;		(* nur fuer FFP *)
BEGIN
  RETURN MathTrans.Fieee(RandomNumber.Random())
END Random;
*)

PROCEDURE RND(nr : INTEGER) : INTEGER;
BEGIN
  RETURN RandomNumber.RND(nr)
END RND;

(*-----------------------------------------------------------------------*)



BEGIN
  InstallPiAndE;
END MathLib.