dws2mathfunctions.pas

script language

{**********************************************************************}
{                                                                      }
{    "The contents of this file are subject to the Mozilla Public      }
{    License Version 1.1 (the "License"); you may not use this         }
{    file except in compliance with the License. You may obtain        }
{    a copy of the License at                                          }
{                                                                      }
{    http://www.mozilla.org/MPL/                                       }
{                                                                      }
{    Software distributed under the License is distributed on an       }
{    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express       }
{    or implied. See the License for the specific language             }
{    governing rights and limitations under the License.               }
{                                                                      }
{    The Original Code is DelphiWebScriptII source code, released      }
{    January 1, 2001                                                   }
{                                                                      }
{    The Initial Developer of the Original Code is Matthias            }
{    Ackermann.                                                        }
{                                                                      }
{    Portions created by Matthias Ackermann are Copyright              }
{                        (C) 2000 Matthias Ackermann, Switzerland.     }
{    Portions created by Eric Grange are Copyright                     }
{                        (C) 2001 Eric Grange, France.                 }
{                                                                      }
{                                                                      }
{    All Rights Reserved.                                              }
{                                                                      }
{                                                                      }
{    Contributor(s): Eric Grange                                       }
{                                                                      }
{    Compatibility:                                                    }
{       [x] D5 (WK)   [x] D6 (WK)    [x] K1 (WK)                       }
{**********************************************************************}

// dws2MathFunctions - Generated : 27.02.01 12:43:46

{$I dws2.inc}
unit dws2MathFunctions;

interface

uses Classes, dws2Functions, dws2Exprs, dws2Symbols;

type
  TIncFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;

  TSinFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TSinFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TSinhFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TSinhFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TCosFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TCosFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TCoshFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TCoshFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TTanFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TTanFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TTanhFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TTanhFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TArcSinFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TArcSinFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TArcSinhFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TArcSinhFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TArcCosFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TArcCosFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TArcCoshFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TArcCoshFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TArcTanFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TArcTanFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TArcTanhFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TArcTanhFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TCotanFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TCotanFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  THypotFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TAbsFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TAbsFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TExpFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TExpFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TLnFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TLnFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TLog2Func = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TLog2FuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TLog10Func = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TLog10FuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TLogNFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TSqrtFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TSqrtFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TSqrFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TSqrFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TIntFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TIntFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TFracFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TFracFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TTruncFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TRoundFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TPowerFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TDegToRadFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TDegToRadFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TRadToDegFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TRadToDegFuncExpr = class(TUnaryOpExpr)
    function Eval: Variant; override;
  end;

  TMaxFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TMinFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TPiFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TPiFuncExpr = class(TExpr)
    function Eval: Variant; override;
  end;

  TRandomFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TRandomIntFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TRandomizeFunc = class(TInternalFunction)
    procedure Execute; override;
    function Optimize(FuncExpr: TExprBase): TExprBase; override;
  end;
  TRandomizeFuncExpr = class(TExpr)
    function Eval: Variant; override;
  end;

  TRandGFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TRandSeedFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

  TSetRandSeedFunc = class(TInternalFunction)
    procedure Execute; override;
  end;

implementation

uses Math;

const // type constants to make sure strings get reused by the compiler
  cFloat = 'Float';
  cInteger = 'Integer';
  cString = 'String';
  cBoolean = 'Boolean';

{ TIncFunc }

procedure TIncFunc.Execute;
begin
  Info['a'] := Info['a'] + Info['b'];
end;

function TIncFunc.Optimize(FuncExpr: TExprBase): TExprBase;
begin
  with FuncExpr as TFuncExpr do
  begin
    Result := TIncrExpr.Create(Prog, Pos, Args[0], Args[1]);
    Args.Clear;
    Free;
  end;
end;

{ TSinFunc }

procedure TSinFunc.Execute;
begin
  Info.Result := Sin(Info['a']);
end;

function TSinFunc.Optimize(FuncExpr: TExprBase): TExprBase;
begin
  with FuncExpr as TFuncExpr do
  begin
    if Args[0] is TConstExpr then
      Result := TConstExpr.Create(Prog, Pos, Prog.TypFloat, Sin(Args[0].Eval))
    else
      Result := TSinFuncExpr.Create(Prog, Pos, Args[0]);
    Args.Clear;
    Free;
  end;
end;

function TSinFuncExpr.Eval: Variant;
begin
  Result := Sin(Expr.Eval);
end;

{ TSinhFunc }

procedure TSinhFunc.Execute;
begin
  Info.Result := Sinh(Info['a']);
end;

function TSinhFunc.Optimize(FuncExpr: TExprBase): TExprBase;
begin
  with FuncExpr as TFuncExpr do
  begin
    if Args[0] is TConstExpr then
      Result := TConstExpr.Create(Prog, Pos, Prog.TypFloat, Sinh(Args[0].Eval))
    else
      Result := TSinhFuncExpr.Create(Prog, Pos, Args[0]);
    Args.Clear;
    Free;
  end;
end;

function TSinhFuncExpr.Eval: Variant;
begin
  Result := Sinh(Expr.Eval);
end;

{ TCosFunc }

procedure TCosFunc.Execute;
begin
  Info.Result := Cos(Info['a']);
end;

function TCosFunc.Optimize(FuncExpr: TExprBase): TExprBase;
begin
  with FuncExpr as TFuncExpr do
  begin
    if Args[0] is TConstExpr then
      Result := TConstExpr.Create(Prog, Pos, Prog.TypFloat, Cos(Args[0].Eval))
    else
      Result := TCosFuncExpr.Create(Prog, Pos, Args[0]);
    Args.Clear;
    Free;
  end;
end;

function TCosFuncExpr.Eval: Variant;
begin
  Result := Cos(Expr.Eval);
end;

{ TCoshFunc }

procedure TCoshFunc.Execute;
begin
  Info.Result := Cosh(Info['a']);
end;

function TCoshFunc.Optimize(FuncExpr: TExprBase): TExprBase;
begin
  with FuncExpr as TFuncExpr do
  begin
    if Args[0] is TConstExpr then
      Result := TConstExpr.Create(Prog, Pos, Prog.TypFloat, Cosh(Args[0].Eval))
    else
      Result := TCoshFuncExpr.Create(Prog, Pos, Args[0]);
    Args.Clear;
    Free;
  end;
end;

function TCoshFuncExpr.Eval: Variant;
begin
  Result := Cosh(Expr.Eval);
end;

{ TTanFunc }

procedure TTanFunc.Execute;
begin
  Info.Result := Tan(Info['a']);
end;

function TTanFunc.Optimize(FuncExpr: TExprBase): TExprBase;
begin
  with FuncExpr as TFuncExpr do
  begin
    if Args[0] is TConstExpr then
      Result := TConstExpr.Create(Prog, Pos, Prog.TypFloat, Tan(Args[0].Eval))
    else
      Result := TTanFuncExpr.Create(Prog, Pos, Args[0]);
    Args.Clear;
    Free;
  end;
end;

function TTanFuncExpr.Eval: Variant;
begin
  Result := Tan(Expr.Eval);
end;

{ TTanhFunc }

procedure TTanhFunc.Execute;
begin
  Info.Result := Tanh(Info['a']);
end;

function TTanhFunc.Optimize(FuncExpr: TExprBase): TExprBase;
begin
  with FuncExpr as TFuncExpr do
  begin
    if Args[0] is TConstExpr then
      Result := TConstExpr.Create(Prog, Pos, Prog.TypFloat, Tanh(Args[0].Eval))
    else
      Result := TTanhFuncExpr.Create(Prog, Pos, Args[0]);
    Args.Clear;
    Free;
  end;
end;

function TTanhFuncExpr.Eval: Variant;
begin
  Result := Tanh(Expr.Eval);
end;

{ TArcSinFunc }

procedure TArcSinFunc.Execute;
begin
  Info.Result := ArcSin(Info['v']);
end;

function TArcSinFunc.Optimize(FuncExpr: TExprBase): TExprBase;
begin
  with FuncExpr as TFuncExpr do
  begin
    if Args[0] is TConstExpr then
      Result := TConstExpr.Create(Prog, Pos, Prog.TypFloat, ArcSin(Args[0].Eval))
    else
      Result := TArcSinFuncExpr.Create(Prog, Pos, Args[0]);
    Args.Clear;
    Free;
  end;
end;

function TArcSinFuncExpr.Eval: Variant;
begin
  Result := ArcSin(Expr.Eval);
end;

{ TArcSinhFunc }

procedure TArcSinhFunc.Execute;
begin
  Info.Result := ArcSinh(Info['v']);
end;

function TArcSinhFunc.Optimize(FuncExpr: TExprBase): TExprBase;
begin
  with FuncExpr as TFuncExpr do
  begin
    if Args[0] is TConstExpr then
      Result := TConstExpr.Create(Prog, Pos, Prog.TypFloat,
        ArcSinh(Args[0].Eval))
    else
      Result := TArcSinhFuncExpr.Create(Prog, Pos, Args[0]);
    Args.Clear;
    Free;
  end;
end;

function TArcSinhFuncExpr.Eval: Variant;
begin
  Result := ArcSinh(Expr.Eval);
end;

{ TArcCosFunc }

procedure TArcCosFunc.Execute;
begin
  Info.Result := ArcCos(Info['v']);
end;

function TArcCosFunc.Optimize(FuncExpr: TExprBase): TExprBase;
begin
  with FuncExpr as TFuncExpr do
  begin
    if Args[0] is TConstExpr then
      Result := TConstExpr.Create(Prog, Pos, Prog.TypFloat, ArcCos(Args[0].Eval))
    else
      Result := TArcCosFuncExpr.Create(Prog, Pos, Args[0]);
    Args.Clear;
    Free;
  end;
end;

function TArcCosFuncExpr.Eval: Variant;
begin
  Result := ArcCos(Expr.Eval);
end;