```Contributor: SWAG SUPPORT TEAM

CONST e = 2.7182818;

Function Exponent(Base: Real; Power: Integer): Real;
{Base can be real, power must be an integer}
VAR
X: INTEGER;
E: REAL;

BEGIN;
E:=1;
If Power = 0 then E:=1
Else If Power = 1 then E:=Base
Else For X:=1 to ABS(Power) do E:=E*Base;
If Power < 0 then E:=1/E;
Exponent:=E;
END;

Function Log(Base, Expnt: Real): Real;
{returns common (base 10) logarithm}
Begin;
Log:=ln(Expnt)/ln(Base);
End;

Function Prime(N: LongInt): Boolean;
{Determines if argument is prime}
Var C: LongInt;
S: Real;
X: Boolean;
Begin;
N:=ABS(N);
S:=SQRT(N);
X:=( (N<=2) OR (ODD(N)) AND (S <> INT(S) ) );
If X then Begin
C:=3;
While (X AND (C < Int(S))) do Begin
X:=((N Mod C) > 0);
C:=C+2;
End; {While}
End; {If X}
Prime:=X;
End; {Prime}

Function Whole(X: Real): Boolean;
Begin;
Whole:=INT(X) = X;
End;

Function Seconds_to_Words(Sec: LongInt): String;
CONST
SecDay=86400;
SecHr=3600;
SecMin=60;
VAR
Days, Hours, Minutes, Seconds: LONGINT;
L: BYTE;
T, X: STRING;

BEGIN;

Days:=Sec DIV SecDay;
Sec:=Sec-(SecDay*Days);
Hours:=Sec DIV SecHr;
Sec:=Sec-(SecHr*Hours);
Minutes:=Sec DIV SecMin;
Sec:=Sec-(SecMin*Minutes);
Seconds:=Sec;

T:='';

If Days > 0 then Begin
Str(Days,T);
T := T + ' Day';
If Days > 1 then T := T + 's';
T := T + ', ';
End; {If Days}

If Hours > 0 then Begin
Str(Hours,X);
T := T + X + ' Hour';
If Hours > 1 then T := T + 's';
T := T + ', ';
End; {If Hours}

If Minutes > 0 then Begin
Str(Minutes,X);
T := T + X + ' Minute';
If Minutes > 1 then T := T + 's';
T := T + ', ';
End; {If Minutes}

If Seconds > 0 then Begin
Str(Seconds,X);
T := T + X + ' Second';
If Seconds > 1 then T := T + 's';
End; {If Seconds}

L:=Length(T)-1;

If T[L] = ',' then T:=Copy(T,1,(L-1));

Seconds_To_Words:=T;

END; {Seconds to Words}

Begin;

Begin;

Begin;

Begin;

Begin;
End;

Begin;

Function Tan(R: Real): Real;
Begin;
Tan:=Sin(R) / Cos(R);
End; {Tan}

Function Csc(R: Real): Real;
Begin;
Csc:=1 / Sin(R);
End; {Csc}

Function Sec(R: Real): Real;
Begin;
Sec:=1 / Cos(R);
End; {Sec}

Function Cot(R: Real): Real;
Begin;
Cot:=Cos(R) / Sin(R);
End; {Cot}

Function Hypotenuse_Equilateral_Triangle(S: Real): Real;
Begin;
Hypotenuse_Equilateral_Triangle:=( SQRT(3) * S ) / 2;
End;

Function Pythagoras(A, B: Real): Real;
Begin;
Pythagoras:=Sqrt((A*A)+(B*B));
End; {Pythagoras}

Function Triangle_Area(B, H: Real): Real;
Begin;
Triangle_Area:=0.5 * B * H;
End; {Triangle Area}

Function Equilateral_Triangle_Area(S: Real): Real;
Begin;
Equilateral_Triangle_Area:=( SQRT(3) * (S*S) ) / 4;
End;

Function Circle_Area(R: Real): Real;
Begin;
Circle_Area:=Pi*(R*R);
End;

Function Ellipse_Area(A, B: Real): Real;
Begin;
Ellipse_Area:=Pi*A*B;
End;

Function Square_Area(S: Real): Real;
Begin;
Square_Area:=(S*S);
End;

Function Rectangle_Area(X, Y: Real): Real;
Begin;
Rectangle_Area:=X*Y;
End;

Function Cube_Surface_Area(S: Real): Real;
Begin;
Cube_Surface_Area:=6*(S*S);
End;

Function Rectangular_Prism_Surface_Area(H, W, L: Real): Real;
Begin;
Rectangular_Prism_Surface_Area:=(2*H*W) + (2*H*L) + (2*L*W);
End;

Function Sphere_Surface_Area(R: Real): Real;
Begin;
Sphere_Surface_Area:=4*Pi*(R*R);
End;

Function Cylinder_Surface_Area(R, H: Real): Real;
Begin;
Cylinder_Surface_Area:=(2*Pi*R*H) + (2*Pi*(R*R));
End;

Function Cone_Surface_Area_Without_Base(R, H: Real): Real;
Begin;
Cone_Surface_Area_Without_Base:=Pi*R*SQRT((R*R) + (H*H) );
End;

Function Cone_Surface_Area_With_Base(R, H: Real): Real;
Begin;
Cone_Surface_Area_With_Base:=(Pi*R*SQRT((R*R) + (H*H)) ) + (Pi*(R*R));
End;

Function Sector_Area(R, A: Real): Real;
Begin;
Sector_Area:=0.5*(R*R)*A;
End;

Function Trapezoid_Area(A, B, H: Real): Real;
Begin;
Trapezoid_Area:=(H / 2) * (A + B);
End;

Function Circle_Circumference(R: Real): Real;
Begin;
Circle_Circumference:=2*Pi*R;
End;

Function Ellipse_Circumference(A, B: Real): Real;
Begin;
Ellipse_Circumference := (2*Pi) * ( SQRT( ( (A*A) + (B*B) ) / 2 ) );
End;

Function Cube_Volume(S: Real): Real;
Begin;
Cube_Volume:=S*S*S;
End;

Function Rectangle_Volume(X, Y, Z: Real): Real;
Begin;
Rectangle_Volume:=X*Y*Z;
End;

Function Sphere_Volume(R: Real): Real;
Begin;
Sphere_Volume:=(4/3)*Pi*(R*R*R);
End;

Function Cylinder_Volume(R, H: Real): Real;
Begin;
Cylinder_Volume:=Pi*(R*R)*H;
End; {Cylinder Volume}

Function Cone_Volume(R, H: Real): Real;
Begin;
Cone_Volume:=(Pi*(R*R)*H)/3;
End;

Function Prism_Volume(B, H: Real): Real;
Begin;
Prism_Volume:=B*H;
End; {Prism Volume}

Function Distance(X1, X2, Y1, Y2: Real): Real;
Begin;
Distance:=Sqrt(Sqr(Y2-Y1)+Sqr(X2-X1));
End; {Distance}

Function Factorial(N: LongInt): LongInt;
Var X, Y: LongInt;
Begin;
If N <> 0 then Begin
X:=N;
For Y:=(N-1) downto 2 do X:=X*Y;
Factorial:=X;
End {If}
Else Factorial:=1;
End; {Factorial}

Function GCF(A, B: LongInt): LongInt;
{finds the Greatest Common Factor between 2 arguments}
Var X, High: LongInt;
Begin;
High:=1;
For X:=2 to A do If (A MOD X = 0)  AND  (B MOD X = 0) then High:=X;
GCF:=High;
End; {GCF}

Function LCM(A, B: LongInt): LongInt;
{finds the Least Common Multiple between 2 arguments}
Var Inc, Low, High: LongInt;
Begin;
If A > B then Begin
High:=A;
Low:=B;
End {If}
Else Begin
High:=B;
Low:=A;
End; {Else}
Inc:=High;
While High MOD Low <> 0 do High:=High+Inc;
LCM:=High;
End; {LCM}

Procedure ISwap(Var X, Y: LongInt);
{swaps 2 Integer or LongInteger variables}
Var Z: LongInt;
Begin;
Z:=X;
X:=Y;
Y:=Z;
End;

Procedure RSwap(Var X, Y: Real);
{swaps 2 REAL variables}
Var Z: Real;
Begin;
Z:=X;
X:=Y;
Y:=Z;
End;

        ```