
(*==============================================================================

     numeric.tl

     This file is part of the TREEFINDER software.


                                    COPYRIGHT (C) 1997-2008 BY GANGOLF JOBB

==============================================================================*)

AbsRaw:=Lookup[Abs], Protect[AbsRaw],

Abs:=<<
 1,'Abs,ThreadOverLists,If1,
 1,'Abs,HandleAlgebraicExpressions,Simplify,If1,
 AbsRaw
>>,
SetMask[Abs,"1"], Protect[Abs],

(*============================================================================*)

AcosRaw:=Lookup[Acos], Protect[AcosRaw],

Acos:=<<
 1,'Acos,ThreadOverLists,If1,
 1,'Acos,HandleAlgebraicExpressions,Simplify,If1,
 AcosRaw
>>,
SetMask[Acos,"1"], Protect[Acos],

(*============================================================================*)

AcoshRaw:=Lookup[Acosh], Protect[AcoshRaw],

Acosh:=<<
 1,'Acosh,ThreadOverLists,If1,
 1,'Acosh,HandleAlgebraicExpressions,Simplify,If1,
 AcoshRaw
>>,
SetMask[Acosh,"1"], Protect[Acosh],

(*============================================================================*)

AddRaw:=Lookup[Add], Protect[AddRaw],

Add:=<<
 0,'Add,ThreadOverLists,If1,
 0,'Add,HandleAlgebraicExpressions,Simplify,If1,
 AddRaw
>>,
SetMask[Add,"{1}"], Protect[Add],

(*============================================================================*)

Add2Raw:=Lookup[Add2], Protect[Add2Raw],

Add2:=<<
 2,'Add,ThreadOverLists,If1,
 2,'Add,HandleAlgebraicExpressions,Simplify,If1,
 Add2Raw
>>,
SetMask[Add2,"11"], Protect[Add2],

(*============================================================================*)

AsinRaw:=Lookup[Asin], Protect[AsinRaw],

Asin:=<<
 1,'Asin,ThreadOverLists,If1,
 1,'Asin,HandleAlgebraicExpressions,Simplify,If1,
 AsinRaw
>>,
SetMask[Asin,"1"], Protect[Asin],

(*============================================================================*)

AsinhRaw:=Lookup[Asinh], Protect[AsinhRaw],

Asinh:=<<
 1,'Asinh,ThreadOverLists,If1,
 1,'Asinh,HandleAlgebraicExpressions,Simplify,If1,
 AsinhRaw
>>,
SetMask[Asinh,"1"], Protect[Asinh],

(*============================================================================*)

AsRealRaw:=Lookup[AsReal], Protect[AsRealRaw],

AsReal:=<<
 1,'AsReal,ThreadOverLists,If1,
 1,'AsReal,HandleAlgebraicExpressions,Simplify,If1,
 AsRealRaw
>>,
SetMask[AsReal,"1"], Protect[AsReal],

(*============================================================================*)

AtanRaw:=Lookup[Atan], Protect[AtanRaw],

Atan:=<<
 1,'Atan,ThreadOverLists,If1,
 1,'Atan,HandleAlgebraicExpressions,Simplify,If1,
 AtanRaw
>>,
SetMask[Atan,"1"], Protect[Atan],

(*============================================================================*)

AtanhRaw:=Lookup[Atanh], Protect[AtanhRaw],

Atanh:=<<
 1,'Atanh,ThreadOverLists,If1,
 1,'Atanh,HandleAlgebraicExpressions,Simplify,If1,
 AtanhRaw
>>,
SetMask[Atanh,"1"], Protect[Atanh],

(*============================================================================*)

BetaRaw:=Lookup[Beta], Protect[BetaRaw],

Beta:=<<
 2,'Beta,ThreadOverLists,If1,
 2,'Beta,HandleAlgebraicExpressions,Simplify,If1,
 BetaRaw
>>,
SetMask[Beta,"11"], Protect[Beta],

(*============================================================================*)

BetaPRaw:=Lookup[BetaP], Protect[BetaPRaw],

BetaP:=<<
 3,'BetaP,ThreadOverLists,If1,
 3,'BetaP,HandleAlgebraicExpressions,Simplify,If1,
 BetaPRaw
>>,
SetMask[BetaP,"111"], Protect[BetaP],

(*============================================================================*)

BetaQRaw:=Lookup[BetaQ], Protect[BetaQRaw],

BetaQ:=<<
 3,'BetaQ,ThreadOverLists,If1,
 3,'BetaQ,HandleAlgebraicExpressions,Simplify,If1,
 BetaQRaw
>>,
SetMask[BetaQ,"111"], Protect[BetaQ],

(*============================================================================*)

BetaXRaw:=Lookup[BetaX], Protect[BetaXRaw],

BetaX:=<<
 3,'BetaX,ThreadOverLists,If1,
 3,'BetaX,HandleAlgebraicExpressions,Simplify,If1,
 BetaXRaw
>>,
SetMask[BetaX,"111"], Protect[BetaX],

(*============================================================================*)

BinomialRaw:=Lookup[Binomial], Protect[BinomialRaw],

Binomial:=<<
 2,'Binomial,ThreadOverLists,If1,
 2,'Binomial,HandleAlgebraicExpressions,Simplify,If1,
 BinomialRaw
>>,
SetMask[Binomial,"11"], Protect[Binomial],

(*============================================================================*)

CbrtRaw:=Lookup[Cbrt], Protect[CbrtRaw],

Cbrt:=<<
 1,'Cbrt,ThreadOverLists,If1,
 1,'Cbrt,HandleAlgebraicExpressions,Simplify,If1,
 CbrtRaw
>>,
SetMask[Cbrt,"1"], Protect[Cbrt],

(*============================================================================*)

CeilingRaw:=Lookup[Ceiling], Protect[CeilingRaw],

Ceiling:=<<
 1,'Ceiling,ThreadOverLists,If1,
 1,'Ceiling,HandleAlgebraicExpressions,Simplify,If1,
 CeilingRaw
>>,
SetMask[Ceiling,"1"], Protect[Ceiling],

(*============================================================================*)

CosRaw:=Lookup[Cos], Protect[CosRaw],

Cos:=<<
 1,'Cos,ThreadOverLists,If1,
 1,'Cos,HandleAlgebraicExpressions,Simplify,If1,
 CosRaw
>>,
SetMask[Cos,"1"], Protect[Cos],

(*============================================================================*)

CoshRaw:=Lookup[Cosh], Protect[CoshRaw],

Cosh:=<<
 1,'Cosh,ThreadOverLists,If1,
 1,'Cosh,HandleAlgebraicExpressions,Simplify,If1,
 CoshRaw
>>,
SetMask[Cosh,"1"], Protect[Cosh],

(*============================================================================*)

CotRaw:=Lookup[Cot], Protect[CotRaw],

Cot:=<<
 1,'Cot,ThreadOverLists,If1,
 1,'Cot,HandleAlgebraicExpressions,Simplify,If1,
 CotRaw
>>,
SetMask[Cot,"1"], Protect[Cot],

(*============================================================================*)

DivRaw:=Lookup[Div], Protect[DivRaw],

Div:=<<
 2,'Div,ThreadOverLists,If1,
 2,'Div,HandleAlgebraicExpressions,Simplify,If1,
 DivRaw
>>,
SetMask[Div,"11"], Protect[Div],

(*============================================================================*)

ErfRaw:=Lookup[Erf], Protect[ErfRaw],

Erf:=<<
 1,'Erf,ThreadOverLists,If1,
 1,'Erf,HandleAlgebraicExpressions,Simplify,If1,
 ErfRaw
>>,
SetMask[Erf,"1"], Protect[Erf],

(*============================================================================*)

ErfcRaw:=Lookup[Erfc], Protect[ErfcRaw],

Erfc:=<<
 1,'Erfc,ThreadOverLists,If1,
 1,'Erfc,HandleAlgebraicExpressions,Simplify,If1,
 ErfcRaw
>>,
SetMask[Erfc,"1"], Protect[Erfc],

(*============================================================================*)

ExpRaw:=Lookup[Exp], Protect[ExpRaw],

Exp:=<<
 1,'Exp,ThreadOverLists,If1,
 1,'Exp,HandleAlgebraicExpressions,Simplify,If1,
 ExpRaw
>>,
SetMask[Exp,"1"], Protect[Exp],

(*============================================================================*)

FactorialRaw:=Lookup[Factorial], Protect[FactorialRaw],

Factorial:=<<
 1,'Factorial,ThreadOverLists,If1,
 1,'Factorial,HandleAlgebraicExpressions,Simplify,If1,
 FactorialRaw
>>,
SetMask[Factorial,"1"], Protect[Factorial],

(*============================================================================*)

FloorRaw:=Lookup[Floor], Protect[FloorRaw],

Floor:=<<
 1,'Floor,ThreadOverLists,If1,
 1,'Floor,HandleAlgebraicExpressions,Simplify,If1,
 FloorRaw
>>,
SetMask[Floor,"1"], Protect[Floor],

(*============================================================================*)

GammaRaw:=Lookup[Gamma], Protect[GammaRaw],

Gamma:=<<
 1,'Gamma,ThreadOverLists,If1,
 1,'Gamma,HandleAlgebraicExpressions,Simplify,If1,
 GammaRaw
>>,
SetMask[Gamma,"1"], Protect[Gamma],

(*============================================================================*)

GammaPRaw:=Lookup[GammaP], Protect[GammaPRaw],

GammaP:=<<
 2,'GammaP,ThreadOverLists,If1,
 2,'GammaP,HandleAlgebraicExpressions,Simplify,If1,
 GammaPRaw
>>,
SetMask[GammaP,"11"], Protect[GammaP],

(*============================================================================*)

GammaQRaw:=Lookup[GammaQ], Protect[GammaQRaw],

GammaQ:=<<
 2,'GammaQ,ThreadOverLists,If1,
 2,'GammaQ,HandleAlgebraicExpressions,Simplify,If1,
 GammaQRaw
>>,
SetMask[GammaQ,"11"], Protect[GammaQ],

(*============================================================================*)

GammaYRaw:=Lookup[GammaY], Protect[GammaYRaw],

GammaY:=<<
 2,'GammaY,ThreadOverLists,If1,
 2,'GammaY,HandleAlgebraicExpressions,Simplify,If1,
 GammaYRaw
>>,
SetMask[GammaY,"11"], Protect[GammaY],

(*============================================================================*)

Hyp2f1Raw:=Lookup[Hyp2f1], Protect[Hyp2f1Raw],

Hyp2f1:=<<
 4,'Hyp2f1,ThreadOverLists,If1,
 4,'Hyp2f1,HandleAlgebraicExpressions,Simplify,If1,
 Hyp2f1Raw
>>,
SetMask[Hyp2f1,"1111"], Protect[Hyp2f1],

(*============================================================================*)

IdivRaw:=Lookup[Idiv], Protect[IdivRaw],

Idiv:=<<
 2,'Idiv,ThreadOverLists,If1,
 2,'Idiv,HandleAlgebraicExpressions,Simplify,If1,
 IdivRaw
>>,
SetMask[Idiv,"11"], Protect[Idiv],

(*============================================================================*)

IerfRaw:=Lookup[Ierf], Protect[IerfRaw],

Ierf:=<<
 1,'Ierf,ThreadOverLists,If1,
 1,'Ierf,HandleAlgebraicExpressions,Simplify,If1,
 IerfRaw
>>,
SetMask[Ierf,"1"], Protect[Ierf],

(*============================================================================*)

InvRaw:=Lookup[Inv], Protect[InvRaw],

Inv:=<<
 1,'Inv,ThreadOverLists,If1,
 1,'Inv,HandleAlgebraicExpressions,Simplify,If1,
 InvRaw
>>,
SetMask[Inv,"1"], Protect[Inv],

(*============================================================================*)

IphiRaw:=Lookup[Iphi], Protect[IphiRaw],

Iphi:=<<
 1,'Iphi,ThreadOverLists,If1,
 1,'Iphi,HandleAlgebraicExpressions,Simplify,If1,
 IphiRaw
>>,
SetMask[Iphi,"1"], Protect[Iphi],

(*============================================================================*)

LdRaw:=Lookup[Ld], Protect[LdRaw],

Ld:=<<
 1,'Ld,ThreadOverLists,If1,
 1,'Ld,HandleAlgebraicExpressions,Simplify,If1,
 LdRaw
>>,
SetMask[Ld,"1"], Protect[Ld],

(*============================================================================*)

LnRaw:=Lookup[Ln], Protect[LnRaw],

Ln:=<<
 1,'Ln,ThreadOverLists,If1,
 1,'Ln,HandleAlgebraicExpressions,Simplify,If1,
 LnRaw
>>,
SetMask[Ln,"1"], Protect[Ln],

(*============================================================================*)

LnBetaRaw:=Lookup[LnBeta], Protect[LnBetaRaw],

LnBeta:=<<
 2,'LnBeta,ThreadOverLists,If1,
 2,'LnBeta,HandleAlgebraicExpressions,Simplify,If1,
 LnBetaRaw
>>,
SetMask[LnBeta,"11"], Protect[LnBeta],

(*============================================================================*)

LnGammaRaw:=Lookup[LnGamma], Protect[LnGammaRaw],

LnGamma:=<<
 1,'LnGamma,ThreadOverLists,If1,
 1,'LnGamma,HandleAlgebraicExpressions,Simplify,If1,
 LnGammaRaw
>>,
SetMask[LnGamma,"1"], Protect[LnGamma],

(*============================================================================*)

LogRaw:=Lookup[Log], Protect[LogRaw],

Log:=<<
 2,'Log,ThreadOverLists,If1,
 2,'Log,HandleAlgebraicExpressions,Simplify,If1,
 LogRaw
>>,
SetMask[Log,"11"], Protect[Log],

(*============================================================================*)

ModRaw:=Lookup[Mod], Protect[ModRaw],

Mod:=<<
 2,'Mod,ThreadOverLists,If1,
 2,'Mod,HandleAlgebraicExpressions,Simplify,If1,
 ModRaw
>>,
SetMask[Mod,"11"], Protect[Mod],

(*============================================================================*)

MulRaw:=Lookup[Mul], Protect[MulRaw],

Mul:=<<
 0,'Mul,ThreadOverLists,If1,
 0,'Mul,HandleAlgebraicExpressions,Simplify,If1,
 MulRaw
>>,
SetMask[Mul,"{1}"], Protect[Mul],

(*============================================================================*)

Mul2Raw:=Lookup[Mul2], Protect[Mul2Raw],

Mul2:=<<
 2,'Mul,ThreadOverLists,If1,
 2,'Mul,HandleAlgebraicExpressions,Simplify,If1,
 Mul2Raw
>>,
SetMask[Mul2,"11"], Protect[Mul2],

(*============================================================================*)

NegRaw:=Lookup[Neg], Protect[NegRaw],

Neg:=<<
 1,'Neg,ThreadOverLists,If1,
 1,'Neg,HandleAlgebraicExpressions,Simplify,If1,
 NegRaw
>>,
SetMask[Neg,"1"], Protect[Neg],

(*============================================================================*)

PhiRaw:=Lookup[Phi], Protect[PhiRaw],

Phi:=<<
 1,'Phi,ThreadOverLists,If1,
 1,'Phi,HandleAlgebraicExpressions,Simplify,If1,
 PhiRaw
>>,
SetMask[Phi,"1"], Protect[Phi],

(*============================================================================*)

PowRaw:=Lookup[Pow], Protect[PowRaw],

Pow:=<<
 2,'Pow,ThreadOverLists,If1,
 2,'Pow,HandleAlgebraicExpressions,Simplify,If1,
 PowRaw
>>,
SetMask[Pow,"11"], Protect[Pow],

(*============================================================================*)

PsiRaw:=Lookup[Psi], Protect[PsiRaw],

Psi:=<<
 1,'Psi,ThreadOverLists,If1,
 1,'Psi,HandleAlgebraicExpressions,Simplify,If1,
 PsiRaw
>>,
SetMask[Psi,"1"], Protect[Psi],

(*============================================================================*)

RgammaRaw:=Lookup[Rgamma], Protect[RgammaRaw],

Rgamma:=<<
 1,'Rgamma,ThreadOverLists,If1,
 1,'Rgamma,HandleAlgebraicExpressions,Simplify,If1,
 RgammaRaw
>>,
SetMask[Rgamma,"1"], Protect[Rgamma],

(*============================================================================*)

SignRaw:=Lookup[Sign], Protect[SignRaw],

Sign:=<<
 1,'Sign,ThreadOverLists,If1,
 1,'Sign,HandleAlgebraicExpressions,Simplify,If1,
 SignRaw
>>,
SetMask[Sign,"1"], Protect[Sign],

(*============================================================================*)

SinRaw:=Lookup[Sin], Protect[SinRaw],

Sin:=<<
 1,'Sin,ThreadOverLists,If1,
 1,'Sin,HandleAlgebraicExpressions,Simplify,If1,
 SinRaw
>>,
SetMask[Sin,"1"], Protect[Sin],

(*============================================================================*)

SinhRaw:=Lookup[Sinh], Protect[SinhRaw],

Sinh:=<<
 1,'Sinh,ThreadOverLists,If1,
 1,'Sinh,HandleAlgebraicExpressions,Simplify,If1,
 SinhRaw
>>,
SetMask[Sinh,"1"], Protect[Sinh],

(*============================================================================*)

SqrtRaw:=Lookup[Sqrt], Protect[SqrtRaw],

Sqrt:=<<
 1,'Sqrt,ThreadOverLists,If1,
 1,'Sqrt,HandleAlgebraicExpressions,Simplify,If1,
 SqrtRaw
>>,
SetMask[Sqrt,"1"], Protect[Sqrt],

(*============================================================================*)

SubRaw:=Lookup[Sub], Protect[SubRaw],

Sub:=<<
 2,'Sub,ThreadOverLists,If1,
 2,'Sub,HandleAlgebraicExpressions,Simplify,If1,
 SubRaw
>>,
SetMask[Sub,"11"], Protect[Sub],

(*============================================================================*)

TanRaw:=Lookup[Tan], Protect[TanRaw],

Tan:=<<
 1,'Tan,ThreadOverLists,If1,
 1,'Tan,HandleAlgebraicExpressions,Simplify,If1,
 TanRaw
>>,
SetMask[Tan,"1"], Protect[Tan],

(*============================================================================*)

TanhRaw:=Lookup[Tanh], Protect[TanhRaw],

Tanh:=<<
 1,'Tanh,ThreadOverLists,If1,
 1,'Tanh,HandleAlgebraicExpressions,Simplify,If1,
 TanhRaw
>>,
SetMask[Tanh,"1"], Protect[Tanh],

(*============================================================================*)

()
