ASFunctions.pas

File name
C:\Users\Andreas Rejbrand\Documents\Dev\AlgoSim\ASFunctions.pas
Date exported
Time exported
Formatting processor
TPascalFormattingProcessor
unit ASFunctions;

{ **************************************************************************** }
{ Rejbrand AlgoSim Kernel Functions                                            }
{ Copyright © 2018-2020 Andreas Rejbrand                                       }
{ https://english.rejbrand.se/                                                 }
{ **************************************************************************** }

{$WARN SYMBOL_PLATFORM OFF}
{$WARN DUPLICATE_CTOR_DTOR OFF}

interface

uses
  SysUtils, Types, Classes, Character, ASNum, ASTree, ASKernelDefs, ASObjects,
  ASObjStore, ASStructs, ASExpression, ASFcnMgr, Generics.Defaults,
  Generics.Collections, ASExecutionContext, Graphics, UITypes, GenHelpers,
  ASKernel, DoublePoint;

type
  [&Function('exprl')]
  [&Category(fcSystem)]
  FCN_ListExprNode = class(TASListExprNode);

  [&Function('identity')]
  [&Category(fcGeneral, fcMath)]
  FCN_Identity = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('add')]
  [&Category(fcGeneral, fcMath, fcStrings, fcSounds)]
  FCN_Add = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('subtract')]
  [&Category(fcGeneral, fcMath, fcSounds)]
  FCN_Subtract = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('negative')]
  [&Category(fcGeneral, fcMath)]
  FCN_UnaryMinus = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('multiply')]
  [&Category(fcGeneral, fcMath, fcStrings, fcSounds)]
  FCN_Multiply = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('InnerProduct')]
  [&Category(fcMath)]
  FCN_InnerProduct = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('divide')]
  [&Category(fcGeneral, fcMath)]
  FCN_Divide = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('power')]
  [&Category(fcMath)]
  FCN_Power = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('cross')]
  [&Category(fcMath)]
  FCN_Cross = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CrossProduct')]
  [&Category(fcMath)]
  FCN_CrossProduct = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('angle', '∠')]
  [&Category(fcMath)]
  FCN_Angle = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('factorial')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_Factorial = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('abs')]
  [&Category(fcMath)]
  FCN_Absolute = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ConjugateTranspose')]
  [&Category(fcMath)]
  FCN_ConjugateTranspose = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('transpose')]
  [&Category(fcMath)]
  FCN_Transpose = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('arg')]
  [&Category(fcMath)]
  FCN_Argument = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Re')]
  [&Category(fcMath)]
  FCN_RealPart = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Im')]
  [&Category(fcMath)]
  FCN_ImaginaryPart = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('sqrt')]
  [&Category(fcMath)]
  FCN_Sqrt = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('degrees')]
  [&Category(fcMath)]
  FCN_Deg = class(TASSimpleFunction)
  strict private
    class var PiDiv180: TAlgosimNumber;
    class constructor ClassCreate;
    class destructor ClassDestroy;
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('percent')]
  [&Category(fcMath)]
  FCN_Percent = class(TASSimpleFunction)
  strict private
    class var OneHundredth: TAlgosimNumber;
    class constructor ClassCreate;
    class destructor ClassDestroy;
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('permille')]
  [&Category(fcMath)]
  FCN_Permille = class(TASSimpleFunction)
  strict private
    class var OneThousandth: TAlgosimNumber;
    class constructor ClassCreate;
    class destructor ClassDestroy;
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('square', 'sqr')]
  [&Category(fcMath)]
  FCN_Square = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('sin')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_sin = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('cos')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_cos = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('tan')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_tan = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('cot')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_cot = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('sec')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_sec = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('csc')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_csc = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('arcsin')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_arcsin = class(TASSimpleFunctionNumDom)
  public
    procedure InitNode; override;
  end;

  [&Function('arccos')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_arccos = class(TASSimpleFunctionNumDom)
  public
    procedure InitNode; override;
  end;

  [&Function('arctan')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_arctan = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('arccot')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_arccot = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('arcsec')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_arcsec = class(TASSimpleFunctionNumDom)
  public
    procedure InitNode; override;
  end;

  [&Function('arccsc')]
  [&Category(fcMath, fcTrigonometry)]
  FCN_arccsc = class(TASSimpleFunctionNumDom)
  public
    procedure InitNode; override;
  end;

  [&Function('sinh')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_sinh = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('cosh')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_cosh = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('tanh')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_tanh = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('coth')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_coth = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('sech')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_sech = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('csch')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_csch = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('arcsinh')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_arcsinh = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('arccosh')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_arccosh = class(TASSimpleFunctionNumDom)
  public
    procedure InitNode; override;
  end;

  [&Function('arctanh')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_arctanh = class(TASSimpleFunctionNumDom)
  public
    procedure InitNode; override;
  end;

  [&Function('arccoth')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_arccoth = class(TASSimpleFunctionNumDom)
  public
    procedure InitNode; override;
  end;

  [&Function('arcsech')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_arcsech = class(TASSimpleFunctionNumDom)
  public
    procedure InitNode; override;
  end;

  [&Function('arccsch')]
  [&Category(fcMath, fcHyperbolic)]
  FCN_arccsch = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('sinc')]
  [&Category(fcMath)]
  FCN_sinc = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('exp')]
  [&Category(fcMath)]
  FCN_exp = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('ln')]
  [&Category(fcMath)]
  FCN_ln = class(TASSimpleFunctionNumDom)
  public
    procedure InitNode; override;
  end;

  [&Function('log')]
  [&Category(fcMath)]
  FCN_log = class(TASSimpleFunctionNumDom)
  public
    procedure InitNode; override;
  end;

  [&Function('floor')]
  [&Category(fcMath)]
  FCN_Floor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ceil')]
  [&Category(fcMath)]
  FCN_Ceil = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('round')]
  [&Category(fcMath)]
  FCN_Round = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('trunc')]
  [&Category(fcMath)]
  FCN_Trunc = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('frac')]
  [&Category(fcMath)]
  FCN_Frac = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('sgn')]
  [&Category(fcMath)]
  FCN_Sgn = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('mod')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_mod = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('lcm')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_lcm = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('gcd')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_gcd = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('combinations', 'binomial')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_combinations = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('permutations')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_permutations = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsPrime')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_IsPrime = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NextPrime')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_NextPrime = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('PrevPrime')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_PrevPrime = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('prime')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_NthPrime = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('PrimePi')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_PrimePi = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Fibonacci')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_Fibonacci = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Lucas')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_Lucas = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('MöbiusMu')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_MöbiusMu = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Mertens')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_Mertens = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('coprime')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_AreCoprime = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Iverson')]
  [&Category(fcMath)]
  FCN_Iverson = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Kronecker')]
  [&Category(fcMath)]
  FCN_Kronecker = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LegendreSymbol')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_LegendreSymbol = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('JacobiSymbol')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_JacobiSymbol = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('KroneckerSymbol')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_KroneckerSymbol = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('totient')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_totient = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('cototient')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_cototient = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('PrimeFactors')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_PrimeFactors = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('rad')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_Radical = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsSquareFree')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_IsSquareFree = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('factors')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_Factorize = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FactorizedExpression')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_FactorizedExpression = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('divisors')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_Divisors = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ContinuedFraction')]
  [&Category(fcMath)]
  FCN_ContinuedFraction = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToFraction')]
  [&Category(fcMath)]
  FCN_ToFraction = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToSymbolicForm')]
  [&Category(fcMath)]
  FCN_ToSymbolicForm = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('erf')]
  [&Category(fcMath)]
  FCN_erf = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('erfc')]
  [&Category(fcMath)]
  FCN_erfc = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('FresnelC')]
  [&Category(fcMath)]
  FCN_FresnelC = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('FresnelS')]
  [&Category(fcMath)]
  FCN_FresnelS = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('Si')]
  [&Category(fcMath)]
  FCN_Si = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('Ci')]
  [&Category(fcMath)]
  FCN_Ci = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('Bessel')]
  [&Category(fcMath)]
  FCN_Bessel = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Laguerre')]
  [&Category(fcMath)]
  FCN_Laguerre = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Hermite')]
  [&Category(fcMath)]
  FCN_Hermite = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Legendre')]
  [&Category(fcMath)]
  FCN_Legendre = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('gamma')]
  [&Category(fcMath)]
  FCN_GammaFunction = class(TASSimpleFunctionNum)
  public
    procedure InitNode; override;
  end;

  [&Function('Chebyshev')]
  [&Category(fcMath)]
  FCN_Chebyshev = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Bernstein')]
  [&Category(fcMath)]
  FCN_Bernstein = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('HarmonicNumber')]
  [&Category(fcMath)]
  FCN_HarmonicNumber = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('and')]
  [&Category(fcLogic)]
  FCN_And = class(TASFunction)
  protected
    procedure DoExecute; override;
    procedure DoBitwise;
  end;

  [&Function('or')]
  [&Category(fcLogic)]
  FCN_Or = class(TASFunction)
  protected
    procedure DoExecute; override;
    procedure DoBitwise;
  end;

  [&Function('not')]
  [&Category(fcLogic)]
  FCN_Not = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('xor')]
  [&Category(fcLogic)]
  FCN_Xor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('nand')]
  [&Category(fcLogic)]
  FCN_Nand = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('nor')]
  [&Category(fcLogic)]
  FCN_Nor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ImpliesRight')]
  [&Category(fcLogic)]
  FCN_ImpliesRight = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ImpliesLeft')]
  [&Category(fcLogic)]
  FCN_ImpliesLeft = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('equivalent')]
  [&Category(fcLogic)]
  FCN_Equivalent = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('equals')]
  [&Category(fcGeneral)]
  FCN_Equals = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NotEquals')]
  [&Category(fcGeneral)]
  FCN_NotEquals = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LessThan')]
  [&Category(fcMath)]
  FCN_LessThan = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LessThanOrEqualTo')]
  [&Category(fcMath)]
  FCN_LessThanOrEqualTo = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GreaterThan')]
  [&Category(fcMath)]
  FCN_GreaterThan = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GreaterThanOrEqualTo')]
  [&Category(fcMath)]
  FCN_GreaterThanOrEqualTo = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('dim')]
  [&Category(fcMath)]
  FCN_Dim = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('size')]
  [&Category(fcMath, fcTables, fcPixmaps)]
  FCN_Size = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('width')]
  [&Category(fcMath, fcTables, fcPixmaps)]
  FCN_Width = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('height')]
  [&Category(fcMath, fcTables, fcPixmaps)]
  FCN_Height = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('subscript')]
  [&Category(fcGeneral)]
  FCN_Subscript = class(TASFunction)
  strict private
    // An array (typically of integers) (when necessary) populated with copies
    // of the values of the child nodes to allow indices as direct children. For
    // instance, A[1, 2] is effectively translated into A['(1, 2)], where
    // '(1, 2) is stored in this array. All code executed later on will only use
    // the array form of the indices.
    FEquivArray: TAlgosimArray;
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
    destructor Destroy; override;
  end;

  FCN_AccessMember = class(TASFunction)
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
  end;

  [&Function('norm')]
  [&Category(fcMath)]
  FCN_Norm = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NormSquared')]
  [&Category(fcMath)]
  FCN_NormSquared = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('normalized')]
  [&Category(fcMath)]
  FCN_Normalized = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('first')]
  [&Category(fcGeneral, fcLists, fcStrings)]
  FCN_First = class(TASFunction)
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
  end;

  [&Function('last')]
  [&Category(fcGeneral, fcLists, fcStrings)]
  FCN_Last = class(TASFunction)
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
  end;

  [&Function('part')]
  [&Category(fcGeneral, fcLists, fcStrings)]
  FCN_Part = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('range')]
  [&Category(fcGeneral, fcLists, fcStrings)]
  FCN_Range = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('sort')]
  [&Category(fcGeneral, fcLists)]
  FCN_Sort = class(TASSimpleFunction)
  private
    rcmp: IComparer<TASR>;
    ccmp: IComparer<TASC>;
    procedure ChooseComparer(const AStr: string);
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CustomSort')]
  [&Category(fcGeneral, fcLists)]
  FCN_CustomSort = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('shuffle')]
  [&Category(fcGeneral, fcLists, fcStrings, fcPixmaps)]
  FCN_Shuffle = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('reverse')]
  [&Category(fcGeneral, fcLists, fcStrings, fcSounds)]
  FCN_Reverse = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('unique', 'RemoveDuplicates')]
  [&Category(fcGeneral, fcLists)]
  FCN_Unique = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RemoveAdjacentDuplicates')]
  [&Category(fcGeneral, fcLists)]
  FCN_AdjUnique = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('frequencies')]
  [&Category(fcGeneral, fcLists)]
  FCN_Frequencies = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('collapse')]
  [&Category(fcLists)]
  FCN_CollapseSequences = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ZeroVector')]
  [&Category(fcMath)]
  FCN_ZeroVector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ComplexZeroVector')]
  [&Category(fcMath)]
  FCN_ComplexZeroVector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RandomVector')]
  [&Category(fcMath)]
  FCN_RandomVector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RandomIntVector')]
  [&Category(fcMath)]
  FCN_RandomIntVector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RandomSignedVector')]
  [&Category(fcMath)]
  FCN_RandomSignedVector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('BasisVector')]
  [&Category(fcMath)]
  FCN_BasisVector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SequenceVector')]
  [&Category(fcMath)]
  FCN_SequenceVector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SequenceList')]
  [&Category(fcMath)]
  FCN_SequenceList = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  TIntervalFunction = class(TASSimpleFunction)
  protected
    OpenInterval: Boolean;
    procedure SimpleFunction; override;
  end;  

  [&Function('ClosedInterval', 'interval')]
  [&Category(fcMath)]
  FCN_ClosedInterval = class(TIntervalFunction)
  protected
    procedure InitNode; override;
  end;

  [&Function('OpenInterval')]
  [&Category(fcMath)]
  FCN_OpenInterval = class(TIntervalFunction)
  protected
    procedure InitNode; override;  
  end;  

  [&Function('random')]
  [&Category(fcGeneral)]
  FCN_Random = class(TASFunction)
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
  end;

  [&Function('RandomInt')]
  [&Category(fcMath)]
  FCN_RandomInt = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RandomReal')]
  [&Category(fcMath)]
  FCN_RandomReal = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetRandomSeed')]
  [&Category(fcMath)]
  FCN_SetRandomSeed = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('randomize')]
  [&Category(fcGeneral)]
  FCN_Randomize = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  TASContainerFunction = class abstract(TASFunction)
  protected
    procedure fcn(AObject: TAlgosimObject); virtual; abstract;
    procedure DoExecute; override; final;
  end;

  [&Function('sum', '∑')]
  [&Category(fcMath)]
  FCN_Sum = class(TASContainerFunction)
  protected
    procedure fcn(AObject: TAlgosimObject); override;
  end;

  [&Function('product', '∏')]
  [&Category(fcMath)]
  FCN_Product = class(TASContainerFunction)
  protected
    procedure fcn(AObject: TAlgosimObject); override;
  end;

  [&Function('min')]
  [&Category(fcMath)]
  FCN_Min = class(TASContainerFunction)
  protected
    procedure fcn(AObject: TAlgosimObject); override;
  end;

  [&Function('max')]
  [&Category(fcMath)]
  FCN_Max = class(TASContainerFunction)
  protected
    procedure fcn(AObject: TAlgosimObject); override;
  end;

  [&Function('ArithmeticMean', 'mean', 'average')]
  [&Category(fcMath)]
  FCN_ArithmeticMean = class(TASContainerFunction)
  protected
    procedure fcn(AObject: TAlgosimObject); override;
  end;

  [&Function('GeometricMean')]
  [&Category(fcMath)]
  FCN_GeometricMean = class(TASContainerFunction)
  protected
    procedure fcn(AObject: TAlgosimObject); override;
  end;

  [&Function('HarmonicMean')]
  [&Category(fcMath)]
  FCN_HarmonicMean = class(TASContainerFunction)
  protected
    procedure fcn(AObject: TAlgosimObject); override;
  end;

  TASContainerPredicateFunction = class abstract(TASFunction)
  protected
    procedure fcn(AObject: TAlgosimObject; APred: TASOPredicate);
      virtual; abstract;
    procedure DoExecute; override;
  end;

  [&Function('count')]
  [&Category(fcGeneral, fcLists)]
  FCN_Count = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('contains')]
  [&Category(fcGeneral, fcLists)]
  FCN_Contains = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('exists', '∃')]
  [&Category(fcGeneral, fcLists)]
  FCN_Exists = class(TASContainerPredicateFunction)
  protected
    procedure fcn(AObject: TAlgosimObject;
      APred: TASOPredicate); override;
  end;

  [&Function('ExistsUnique')]
  [&Category(fcGeneral, fcLists)]
  FCN_ExistsUnique = class(TASContainerPredicateFunction)
  protected
    procedure fcn(AObject: TAlgosimObject;
      APred: TASOPredicate); override;
  end;

  [&Function('ForAll', '∀')]
  [&Category(fcGeneral, fcLists)]
  FCN_ForAll = class(TASContainerPredicateFunction)
  protected
    procedure fcn(AObject: TAlgosimObject;
      APred: TASOPredicate); override;
  end;

  [&Function('indices')]
  [&Category(fcGeneral, fcLists)]
  FCN_IndicesOf = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('filter')]
  [&Category(fcGeneral, fcLists)]
  FCN_Filter = class(TASContainerPredicateFunction)
  protected
    procedure fcn(AObject: TAlgosimObject;
      APred: TASOPredicate); override;
  end;

  [&Function('pick')]
  [&Category(fcGeneral, fcLists)]
  FCN_Pick = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('PickRecursive')]
  [&Category(fcGeneral, fcLists)]
  FCN_PickRecursive = class(TASContainerPredicateFunction)
  protected
    procedure fcn(AObject: TAlgosimObject;
      APred: TASOPredicate); override;
  end;

  [&Function('apply')]
  [&Category(fcGeneral, fcLists)]
  FCN_Apply = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ApplyIf')]
  [&Category(fcGeneral, fcLists)]
  FCN_ApplyIf = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReplaceAll')]
  [&Category(fcGeneral, fcLists)]
  FCN_ReplaceAll = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReplaceIf')]
  [&Category(fcGeneral, fcLists)]
  FCN_ReplaceIf = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReplaceEvery')]
  [&Category(fcGeneral, fcLists)]
  FCN_ReplaceEvery = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RemoveAll')]
  [&Category(fcGeneral, fcLists)]
  FCN_RemoveAll = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RemoveIf')]
  [&Category(fcGeneral, fcLists)]
  FCN_RemoveIf = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RealNumber')]
  [&Category(fcGeneral)]
  FCN_RealNumber = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ComplexNumber')]
  [&Category(fcGeneral)]
  FCN_ComplexNumber = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('number')]
  [&Category(fcGeneral)]
  FCN_Number = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('integer')]
  [&Category(fcGeneral)]
  FCN_Integer = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('string')]
  [&Category(fcGeneral)]
  FCN_String = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RealVector')]
  [&Category(fcGeneral)]
  FCN_RealVector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ComplexVector')]
  [&Category(fcGeneral)]
  FCN_ComplexVector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('vector')]
  [&Category(fcGeneral, fcMath)]
  FCN_Vector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RealMatrix')]
  [&Category(fcGeneral)]
  FCN_RealMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ComplexMatrix')]
  [&Category(fcGeneral)]
  FCN_ComplexMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('matrix')]
  [&Category(fcGeneral, fcMath)]
  FCN_Matrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('boolean')]
  [&Category(fcGeneral)]
  FCN_Boolean = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToList')]
  [&Category(fcGeneral)]
  FCN_ToList = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToSet')]
  [&Category(fcGeneral)]
  FCN_ToSet = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToTable')]
  [&Category(fcGeneral)]
  FCN_ToTable = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('BinaryData')]
  [&Category(fcGeneral)]
  FCN_BinaryData = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('MatFromCols')]
  [&Category(fcGeneral, fcMath)]
  FCN_MatrixFromCols = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('MatFromRows')]
  [&Category(fcGeneral, fcMath)]
  FCN_MatrixFromRows = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('MatFromBlocks')]
  [&Category(fcGeneral, fcMath)]
  FCN_MatrixFromBlocks = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('list', '''')]
  [&Category(fcLists)]
  FCN_List = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('set')]
  [&Category(fcSets)]
  FCN_Set = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('union')]
  [&Category(fcSets)]
  FCN_Union = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('intersection')]
  [&Category(fcSets)]
  FCN_Intersection = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetDifference')]
  [&Category(fcSets)]
  FCN_SetDifference = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SymmetricDifference')]
  [&Category(fcSets)]
  FCN_SymDiff = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('complement')]
  [&Category(fcSets)]
  FCN_Complement = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ElementOf')]
  [&Category(fcSets)]
  FCN_ElementOf = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NotElementOf')]
  [&Category(fcSets)]
  FCN_NotElementOf = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ContainsAsElement')]
  [&Category(fcSets)]
  FCN_ContainsAsElement = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NotContainsAsElement')]
  [&Category(fcSets)]
  FCN_NotContainsAsElement = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('subset')]
  [&Category(fcSets)]
  FCN_Subset = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ProperSubset')]
  [&Category(fcSets)]
  FCN_ProperSubset = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('superset')]
  [&Category(fcSets)]
  FCN_Superset = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ProperSuperset')]
  [&Category(fcSets)]
  FCN_ProperSuperset = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('type')]
  [&Category(fcSystem)]
  FCN_TypeName = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('ClassData')]
  [&Category(fcSystem)]
  FCN_ClassTypeData = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('class')]
  [&Category(fcSystem)]
  FCN_ClassTypeName = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('HasComplexType')]
  [&Category(fcSystem)]
  FCN_HasComplexType = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('IsObjectContainer')]
  [&Category(fcSystem)]
  FCN_IsObjectContainer = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('IsValueContainer')]
  [&Category(fcSystem)]
  FCN_IsValueContainer = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('IsPlanarContainer')]
  [&Category(fcSystem)]
  FCN_IsPlanarContainer = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('IsOrderedContainer')]
  [&Category(fcSystem)]
  FCN_IsOrderedContainer = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('beep')]
  [&Category(fcSystem)]
  FCN_Beep = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('wait', 'sleep')]
  [&Category(fcSystem)]
  FCN_Wait = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TickCount')]
  [&Category(fcSystem)]
  FCN_GetTickCount = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Heaviside')]
  [&Category(fcMath)]
  FCN_Heaviside = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('ramp')]
  [&Category(fcMath)]
  FCN_Ramp = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('rect')]
  [&Category(fcMath)]
  FCN_Rect = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('tri')]
  [&Category(fcMath)]
  FCN_Tri = class(TASSimpleFunctionReal)
  public
    procedure InitNode; override;
  end;

  [&Function('property')]
  [&Category(fcSystem)]
  FCN_GetProperty = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('integrate', '∫')]
  [&Category(fcMath)]
  FCN_Integrate = class abstract(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('differentiate', 'diff')]
  [&Category(fcMath)]
  FCN_Differentiate = class abstract(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('length', 'cardinality', 'card')]
  [&Category(fcGeneral, fcLists, fcStrings, fcStructures, fcSets)]
  FCN_Length = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('StringPos')]
  [&Category(fcStrings)]
  FCN_Pos = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('StringContains')]
  [&Category(fcStrings)]
  FCN_StringContains = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('StringCount')]
  [&Category(fcStrings)]
  FCN_SubstringCount = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('StringIndices')]
  [&Category(fcStrings)]
  FCN_SubstringIndices = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('StringReplace')]
  [&Category(fcStrings)]
  FCN_StringReplace = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('split')]
  [&Category(fcStrings)]
  FCN_Split = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('join')]
  [&Category(fcStrings)]
  FCN_Join = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('UpperCase')]
  [&Category(fcStrings)]
  FCN_UpperCase = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LowerCase')]
  [&Category(fcStrings)]
  FCN_LowerCase = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('InvertCase')]
  [&Category(fcStrings)]
  FCN_InvertCase = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TitleCase')]
  [&Category(fcStrings)]
  FCN_TitleCase = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SentenceCase')]
  [&Category(fcStrings)]
  FCN_SentenceCase = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('rot13')]
  [&Category(fcStrings)]
  FCN_ROT13 = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Caesar')]
  [&Category(fcStrings)]
  FCN_Caesar = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('VigenèreEncode')]
  [&Category(fcStrings)]
  FCN_Vigenère = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('VigenèreDecode')]
  [&Category(fcStrings)]
  FCN_VigenèreDecode = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('trim')]
  [&Category(fcStrings)]
  FCN_Trim = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TrimLeft')]
  [&Category(fcStrings)]
  FCN_TrimLeft = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TrimRight')]
  [&Category(fcStrings)]
  FCN_TrimRight = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('StringPad')]
  [&Category(fcStrings)]
  FCN_Pad = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('format')]
  [&Category(fcStrings)]
  FCN_Format = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('index')]
  [&Category(fcGeneral, fcLists, fcStructures)]
  FCN_IndexOf = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  TCharTestFunction = class abstract(TASSimpleFunction)
  protected
  type
    TChrTestFcn = function(C: char): Boolean;
  var
    fcn: TChrTestFcn;
    procedure SimpleFunction; override; final;
  end;

  [&Function('ChrIsLetter')]
  [&Category(fcStrings)]
  FCN_ChrIsLetter = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsDigit')]
  [&Category(fcStrings)]
  FCN_ChrIsDigit = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsLetterOrDigit')]
  [&Category(fcStrings)]
  FCN_ChrIsLetterOrDigit = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsNumber')]
  [&Category(fcStrings)]
  FCN_ChrIsNumber = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsPunctuation')]
  [&Category(fcStrings)]
  FCN_ChrIsPunctuation = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsSeparator')]
  [&Category(fcStrings)]
  FCN_ChrIsSeparator = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsWhitespace')]
  [&Category(fcStrings)]
  FCN_ChrIsWhitespace = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsUpperCase')]
  [&Category(fcStrings)]
  FCN_ChrIsUpperCase = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsLowerCase')]
  [&Category(fcStrings)]
  FCN_ChrIsLowerCase = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsSymbol')]
  [&Category(fcStrings)]
  FCN_ChrIsSymbol = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsASCII')]
  [&Category(fcStrings)]
  FCN_ChrIsASCII = class(TCharTestFunction)
  strict private
    class function IsASCII(C: char): Boolean; static; inline;
  public
    procedure InitNode; override;
  end;

  [&Function('ChrIsControl')]
  [&Category(fcStrings)]
  FCN_ChrIsControl = class(TCharTestFunction)
  public
    procedure InitNode; override;
  end;

  [&Function('ChrName')]
  [&Category(fcStrings)]
  FCN_ChrName = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ChrBlock')]
  [&Category(fcStrings)]
  FCN_ChrBlock = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ChrBlocks')]
  [&Category(fcStrings)]
  FCN_ListChrBlocks = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ChrBlockRange')]
  [&Category(fcStrings)]
  FCN_ChrBlockRange = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('chr')]
  [&Category(fcStrings)]
  FCN_Character = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ord')]
  [&Category(fcStrings)]
  FCN_ChrCode = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ChrNumVal')]
  [&Category(fcStrings)]
  FCN_ChrNumVal = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('odd')]
  [&Category(fcMath)]
  FCN_Odd = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('even')]
  [&Category(fcMath)]
  FCN_Even = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('date')]
  [&Category(fcDateTime)]
  FCN_Date = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('time')]
  [&Category(fcDateTime)]
  FCN_Time = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('now')]
  [&Category(fcDateTime)]
  FCN_Now = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('datetime')]
  [&Category(fcDateTime)]
  FCN_DateTime = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  TTimeOneParamFcn = class abstract(TASSimpleFunction)
  protected
    type
      TTimeOneParamFcn32 = function(const ADateTime: TDateTime; const AParam: Integer): TDateTime;
      TTimeOneParamFcn64 = function(const ADateTime: TDateTime; const AParam: Int64): TDateTime;
    var
      fcn32: TTimeOneParamFcn32;
      fcn64: TTimeOneParamFcn64;

    procedure SimpleFunction; override; final;
  end;

  [&Function('AddMilliseconds')]
  [&Category(fcDateTime)]
  FCN_AddMilliseconds = class(TTimeOneParamFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('AddSeconds')]
  [&Category(fcDateTime)]
  FCN_AddSeconds = class(TTimeOneParamFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('AddMinutes')]
  [&Category(fcDateTime)]
  FCN_AddMinutes = class(TTimeOneParamFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('AddHours')]
  [&Category(fcDateTime)]
  FCN_AddHours = class(TTimeOneParamFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('AddDays')]
  [&Category(fcDateTime)]
  FCN_AddDays = class(TTimeOneParamFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('AddWeeks')]
  [&Category(fcDateTime)]
  FCN_AddWeeks = class(TTimeOneParamFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('AddMonths')]
  [&Category(fcDateTime)]
  FCN_AddMonths = class(TTimeOneParamFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('AddYears')]
  [&Category(fcDateTime)]
  FCN_AddYears = class(TTimeOneParamFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('IsValidDate')]
  [&Category(fcDateTime)]
  FCN_DateValid = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsValidTime')]
  [&Category(fcDateTime)]
  FCN_TimeValid = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsValidDatetime')]
  [&Category(fcDateTime)]
  FCN_DateTimeValid = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  TTimeTimeDoubleFcn = class abstract(TASSimpleFunction)
  protected
    type
      _TTimeTimeDoubleFcn = function(const ATime1, ATime2: TDateTime): double;
    var
      fcn: _TTimeTimeDoubleFcn;

    procedure SimpleFunction; override; final;
  end;

  [&Function('MillisecondsBetween')]
  [&Category(fcDateTime)]
  FCN_MillisecondsBetween = class(TTimeTimeDoubleFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('SecondsBetween')]
  [&Category(fcDateTime)]
  FCN_SecondsBetween = class(TTimeTimeDoubleFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('MinutesBetween')]
  [&Category(fcDateTime)]
  FCN_MinutesBetween = class(TTimeTimeDoubleFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('HoursBetween')]
  [&Category(fcDateTime)]
  FCN_HoursBetween = class(TTimeTimeDoubleFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('DaysBetween')]
  [&Category(fcDateTime)]
  FCN_DaysBetween = class(TTimeTimeDoubleFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('WeeksBetween')]
  [&Category(fcDateTime)]
  FCN_WeeksBetween = class(TTimeTimeDoubleFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('MonthsBetween')]
  [&Category(fcDateTime)]
  FCN_MonthsBetween = class(TTimeTimeDoubleFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('YearsBetween')]
  [&Category(fcDateTime)]
  FCN_YearsBetween = class(TTimeTimeDoubleFcn)
  public
    procedure InitNode; override;
  end;

  TTimeIntFcn = class abstract(TASSimpleFunction)
  protected
    type
      TTimeIntFcn16 = function(const ADateTime: TDateTime): Word;
      TTimeIntFcn32 = function(const ADateTime: TDateTime): Cardinal;
      TTimeIntFcn64 = function(const ADateTime: TDateTime): Int64;
    var
      fcn16: TTimeIntFcn16;
      fcn32: TTimeIntFcn32;
      fcn64: TTimeIntFcn64;
      IntFmt: TFormatStyle;

    procedure SimpleFunction; override;
  end;

  [&Function('DayOfTheWeek')]
  [&Category(fcDateTime)]
  FCN_DayOfTheWeek = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('DayOfTheMonth')]
  [&Category(fcDateTime)]
  FCN_DayOfTheMonth = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('DayOfTheYear')]
  [&Category(fcDateTime)]
  FCN_DayOfTheYear = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('WeekOfTheYear')]
  [&Category(fcDateTime)]
  FCN_WeekOfTheYear = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('SecondOfTheDay')]
  [&Category(fcDateTime)]
  FCN_SecondOfTheDay = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('SecondOfTheWeek')]
  [&Category(fcDateTime)]
  FCN_SecondOfTheWeek = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('SecondOfTheMonth')]
  [&Category(fcDateTime)]
  FCN_SecondOfTheMonth = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('SecondOfTheYear')]
  [&Category(fcDateTime)]
  FCN_SecondOfTheYear = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('MillisecondOfTheDay')]
  [&Category(fcDateTime)]
  FCN_MillisecondOfTheDay = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('MillisecondOfTheWeek')]
  [&Category(fcDateTime)]
  FCN_MillisecondOfTheWeek = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('MillisecondOfTheMonth')]
  [&Category(fcDateTime)]
  FCN_MillisecondOfTheMonth = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('MillisecondOfTheYear')]
  [&Category(fcDateTime)]
  FCN_MillisecondOfTheYear = class(TTimeIntFcn)
  public
    procedure InitNode; override;
  end;

  [&Function('IsLeapYear')]
  [&Category(fcDateTime)]
  FCN_IsLeapYear = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DaysInYear')]
  [&Category(fcDateTime)]
  FCN_DaysInYear = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DaysInMonth')]
  [&Category(fcDateTime)]
  FCN_DaysInMonth = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('timestamp')]
  [&Category(fcDateTime)]
  FCN_Timestamp = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('today')]
  [&Category(fcDateTime)]
  FCN_Today = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('tomorrow')]
  [&Category(fcDateTime)]
  FCN_Tomorrow = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('yesterday')]
  [&Category(fcDateTime)]
  FCN_Yesterday = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TruncToMillisecond')]
  [&Category(fcDateTime)]
  FCN_TruncateToMillisecond = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TruncToSecond')]
  [&Category(fcDateTime)]
  FCN_TruncateToSecond = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TruncToMinute')]
  [&Category(fcDateTime)]
  FCN_TruncateToMinute = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TruncToHour')]
  [&Category(fcDateTime)]
  FCN_TruncateToHour = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TruncToDay')]
  [&Category(fcDateTime)]
  FCN_TruncateToDay = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TruncToMonth')]
  [&Category(fcDateTime)]
  FCN_TruncateToMonth = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TruncToYear')]
  [&Category(fcDateTime)]
  FCN_TruncateToYear = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NumDigits')]
  [&Category(fcSystem)]
  FCN_NumDigits = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('MinLength')]
  [&Category(fcSystem)]
  FCN_MinLength = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('NumberFormat')]
  [&Category(fcSystem)]
  FCN_NumberFormat = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('NumberBase')]
  [&Category(fcSystem)]
  FCN_NumberBase = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('FormatStyle')]
  [&Category(fcSystem)]
  FCN_FormatStyle = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('DigitGrouping')]
  [&Category(fcSystem)]
  FCN_DigitGrouping = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('PrettyExp')]
  [&Category(fcSystem)]
  FCN_PrettyExp = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('MaxLen')]
  [&Category(fcSystem)]
  FCN_MaxLen = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('SetNumDigits')]
  [&Category(fcSystem)]
  FCN_SetNumDigits = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetMinLength')]
  [&Category(fcSystem)]
  FCN_SetMinLength = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetNumberFormat')]
  [&Category(fcSystem)]
  FCN_SetNumberFormat = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetNumberBase')]
  [&Category(fcSystem)]
  FCN_SetNumberBase = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetFormatStyle')]
  [&Category(fcSystem)]
  FCN_SetFormatStyle = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetDigitGrouping')]
  [&Category(fcSystem)]
  FCN_SetDigitGrouping = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetPrettyExp')]
  [&Category(fcSystem)]
  FCN_SetPrettyExp = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetMaxLen')]
  [&Category(fcSystem)]
  FCN_SetMaxLen = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AsSingleLine')]
  [&Category(fcSystem)]
  FCN_AsSingleLine = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('InputForm')]
  [&Category(fcSystem)]
  FCN_InputForm = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('AsMultiLine')]
  [&Category(fcSystem)]
  FCN_AsMultiLine = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('SaveToFile', 'export')]
  [&Category(fcSystem)]
  FCN_SaveToFile = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('LoadFromFile')]
  [&Category(fcSystem)]
  FCN_LoadFromFile = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CopyToClipboard')]
  [&Category(fcSystem)]
  FCN_CopyToClipboard = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('flatten')]
  [&Category(fcLists)]
  FCN_Flatten = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('group')]
  [&Category(fcLists)]
  FCN_Group = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  TSymbolNameFcn = class(TASFunction)
  protected
    procedure DoExecute; override; final;
    procedure fcn(const ASymbolName: string); virtual; abstract;
  end;

  [&Function('variable')]
  [&Category(fcSystem)]
  FCN_Variable = class(TSymbolNameFcn)
  protected
    procedure fcn(const ASymbolName: string); override;
  end;

  [&Function('object')]
  [&Category(fcSystem)]
  FCN_Object = class(TSymbolNameFcn)
  protected
    procedure fcn(const ASymbolName: string); override;
  end;

  [&Function('metadata')]
  [&Category(fcSystem)]
  FCN_Metadata = class(TSymbolNameFcn)
  protected
    procedure fcn(const ASymbolName: string); override;
  end;

  [&Function('description')]
  [&Category(fcSystem)]
  FCN_Description = class(TSymbolNameFcn)
  protected
    procedure fcn(const ASymbolName: string); override;
  end;

  [&Function('delete')]
  [&Category(fcSystem)]
  FCN_Delete = class(TSymbolNameFcn)
  protected
    procedure fcn(const ASymbolName: string); override;
  end;

  [&Function('protect')]
  [&Category(fcSystem)]
  FCN_Protect = class(TSymbolNameFcn)
  protected
    procedure fcn(const ASymbolName: string); override;
  end;

  [&Function('unprotect')]
  [&Category(fcSystem)]
  FCN_Unprotect = class(TSymbolNameFcn)
  protected
    procedure fcn(const ASymbolName: string); override;
  end;

  [&Function('assign')]
  [&Category(fcSystem)]
  FCN_Assign = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('cls')]
  [&Category(fcSystem)]
  FCN_Cls = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('exit')]
  [&Category(fcSystem)]
  FCN_Exit = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('error', 'fail')]
  [&Category(fcSystem)]
  FCN_Fail = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('assert')]
  [&Category(fcSystem)]
  FCN_Assert = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('succeeded')]
  [&Category(fcSystem)]
  FCN_Succeeded = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('try')]
  [&Category(fcSystem)]
  FCN_Try = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('piecewise')]
  [&Category(fcMath)]
  FCN_Piecewise = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('MakeMember')]
  [&Category(fcStructures)]
  FCN_MakeMember = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('struct', 'structure')]
  [&Category(fcStructures)]
  FCN_MakeStruct = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('system')]
  [&Category(fcSystem)]
  FCN_System = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RotLeft')]
  [&Category(fcGeneral)]
  FCN_RotLeft = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RotRight')]
  [&Category(fcGeneral)]
  FCN_RotRight = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('diag')]
  [&Category(fcMath)]
  FCN_Diag = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('row')]
  [&Category(fcGeneral, fcMath, fcTables)]
  FCN_Row = class(TASFunction)
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
  end;

  [&Function('col')]
  [&Category(fcGeneral, fcMath, fcTables)]
  FCN_Col = class(TASFunction)
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
  end;

  [&Function('rows')]
  [&Category(fcGeneral, fcMath, fcTables)]
  FCN_Rows = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('cols')]
  [&Category(fcGeneral, fcMath, fcTables)]
  FCN_Cols = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('MainDiagonal')]
  [&Category(fcMath)]
  FCN_MainDiagonal = class(TASFunction)
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
  end;

  [&Function('superdiagonal')]
  [&Category(fcMath)]
  FCN_Superdiagonal = class(TASFunction)
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
  end;

  [&Function('subdiagonal')]
  [&Category(fcMath)]
  FCN_Subdiagonal = class(TASFunction)
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
  end;

  [&Function('antidiagonal')]
  [&Category(fcMath)]
  FCN_Antidiagonal = class(TASFunction)
  protected
    procedure DoExecute; override;
  public
    function BuildLValue(LValueData: TLValueData): Boolean; override;
    function LValuePart: Boolean; override;
  end;

  [&Function('ReplaceRow')]
  [&Category(fcMath)]
  FCN_ReplaceRow = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReplaceCol')]
  [&Category(fcMath)]
  FCN_ReplaceCol = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReplaceDiagonal')]
  [&Category(fcMath)]
  FCN_ReplaceDiagonal = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReplaceSuperdiagonal')]
  [&Category(fcMath)]
  FCN_ReplaceSuperdiagonal = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReplaceSubdiagonal')]
  [&Category(fcMath)]
  FCN_ReplaceSubdiagonal = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReplaceAntidiagonal')]
  [&Category(fcMath)]
  FCN_ReplaceAntidiagonal = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsRow')]
  [&Category(fcGeneral, fcMath, fcPixmaps, fcTables)]
  FCN_IsRow = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('IsCol')]
  [&Category(fcGeneral, fcMath, fcPixmaps, fcTables)]
  FCN_IsCol = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('IsSquare')]
  [&Category(fcGeneral, fcMath, fcPixmaps, fcTables)]
  FCN_IsSquare = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  TMatrixEpsilonFunction<T> = class abstract(TASFunction)
  strict protected
    type
      TEpsilonFcn = function(const Epsilon: Extended = 0): T of object;
    var
      rfcn, cfcn: TEpsilonFcn;
      generic_result: T;
    class var
      _TRealMatrix: TRealMatrix; // only used in child classes to get method code ptrs in a semi-type-safe manner
      _TComplexMatrix: TComplexMatrix;
  protected
    procedure DoExecute; override;
  end;

  TMatrixQueryWithEpsilon = class abstract(TMatrixEpsilonFunction<Boolean>)
  protected
    procedure DoExecute; override;
  end;

  [&Function('IsIdentity')]
  [&Category(fcMath)]
  FCN_IsIdentity = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsZeroMatrix')]
  [&Category(fcMath)]
  FCN_IsZeroMatrix = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsDiagonal')]
  [&Category(fcMath)]
  FCN_IsDiagonal = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsAntidiagonal')]
  [&Category(fcMath)]
  FCN_IsAntiDiagonal = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsReversal')]
  [&Category(fcMath)]
  FCN_IsReversal = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsUpperTriangular')]
  [&Category(fcMath)]
  FCN_IsUpperTriangular = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsLowerTriangular')]
  [&Category(fcMath)]
  FCN_IsLowerTriangular = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsTriangular')]
  [&Category(fcMath)]
  FCN_IsTriangular = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsRowEchelonForm')]
  [&Category(fcMath)]
  FCN_IsRowEchelonForm = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsReducedRowEchelonForm')]
  [&Category(fcMath)]
  FCN_IsReducedRowEchelonForm = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsScalar')]
  [&Category(fcMath)]
  FCN_IsScalar = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsSymmetric')]
  [&Category(fcMath)]
  FCN_IsSymmetric = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsSkewSymmetric')]
  [&Category(fcMath)]
  FCN_IsSkewSymmetric = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsHermitian', 'IsSelfAdjoint')]
  [&Category(fcMath)]
  FCN_IsHermitian = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsSkewHermitian')]
  [&Category(fcMath)]
  FCN_IsSkewHermitian = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsOrthogonal')]
  [&Category(fcMath)]
  FCN_IsOrthogonal = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsUnitary')]
  [&Category(fcMath)]
  FCN_IsUnitary = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsNormal')]
  [&Category(fcMath)]
  FCN_IsNormal = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsBinary')]
  [&Category(fcMath)]
  FCN_IsBinary = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsPermutation')]
  [&Category(fcMath)]
  FCN_IsPermutation = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsCirculant')]
  [&Category(fcMath)]
  FCN_IsCirculant = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsToeplitz')]
  [&Category(fcMath)]
  FCN_IsToeplitz = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsHankel')]
  [&Category(fcMath)]
  FCN_IsHankel = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsUpperHessenberg')]
  [&Category(fcMath)]
  FCN_IsUpperHessenberg = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsLowerHessenberg')]
  [&Category(fcMath)]
  FCN_IsLowerHessenberg = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsTridiagonal')]
  [&Category(fcMath)]
  FCN_IsTridiagonal = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsUpperBidiagonal')]
  [&Category(fcMath)]
  FCN_IsUpperBidiagonal = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsLowerBidiagonal')]
  [&Category(fcMath)]
  FCN_IsLowerBidiagonal = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsBidiagonal')]
  [&Category(fcMath)]
  FCN_IsBidiagonal = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsCentrosymmetric')]
  [&Category(fcMath)]
  FCN_IsCentrosymmetric = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsVandermonde')]
  [&Category(fcMath)]
  FCN_IsVandermonde = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsIdempotent')]
  [&Category(fcMath)]
  FCN_IsIdempotent = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsInvolution')]
  [&Category(fcMath)]
  FCN_IsInvolution = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsPositiveDefinite')]
  [&Category(fcMath)]
  FCN_IsPositiveDefinite = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsPositiveSemidefinite')]
  [&Category(fcMath)]
  FCN_IsPositiveSemidefinite = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsNegativeDefinite')]
  [&Category(fcMath)]
  FCN_IsNegativeDefinite = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsNegativeSemidefinite')]
  [&Category(fcMath)]
  FCN_IsNegativeSemidefinite = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsIndefinite')]
  [&Category(fcMath)]
  FCN_IsIndefinite = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  [&Function('IsNilpotent')]
  [&Category(fcMath)]
  FCN_IsNilpotent = class(TMatrixQueryWithEpsilon)
    procedure InitNode; override;
  end;

  TMatrixIntFcnWithEpsilon = class abstract(TMatrixEpsilonFunction<Integer>)
  protected
    procedure DoExecute; override;
  end;

  [&Function('NilpotencyIndex')]
  [&Category(fcMath)]
  FCN_NilpotencyIndex = class(TMatrixIntFcnWithEpsilon)
  protected
    procedure InitNode; override;
  end;

  TNumEntEpsilonFunction = class abstract(TASFunction)
  protected
    procedure fcn(AObj: TAlgosimNumericEntity; const AEps: TASR); virtual; abstract;
    procedure DoExecute; override; final;
  end;

  [&Function('IsPositive')]
  [&Category(fcMath)]
  FCN_IsPositive = class(TNumEntEpsilonFunction)
  protected
    procedure fcn(AObj: TAlgosimNumericEntity; const AEps: TASR); override;
  end;

  [&Function('IsNonNegative')]
  [&Category(fcMath)]
  FCN_IsNonNegative = class(TNumEntEpsilonFunction)
  protected
    procedure fcn(AObj: TAlgosimNumericEntity; const AEps: TASR); override;
  end;

  [&Function('IsNegative')]
  [&Category(fcMath)]
  FCN_IsNegative = class(TNumEntEpsilonFunction)
  protected
    procedure fcn(AObj: TAlgosimNumericEntity; const AEps: TASR); override;
  end;

  [&Function('IsNonPositive')]
  [&Category(fcMath)]
  FCN_IsNonPositive = class(TNumEntEpsilonFunction)
  protected
    procedure fcn(AObj: TAlgosimNumericEntity; const AEps: TASR); override;
  end;

  [&Function('IsZero')]
  [&Category(fcMath)]
  FCN_IsZero = class(TNumEntEpsilonFunction)
  protected
    procedure fcn(AObj: TAlgosimNumericEntity; const AEps: TASR); override;
  end;

  [&Function('IsNonZero')]
  [&Category(fcMath)]
  FCN_IsNonZero = class(TNumEntEpsilonFunction)
  protected
    procedure fcn(AObj: TAlgosimNumericEntity; const AEps: TASR); override;
  end;

  [&Function('PivotPos')]
  [&Category(fcMath)]
  FCN_PivotPos = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsZeroRow')]
  [&Category(fcMath)]
  FCN_IsZeroRow = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsEssentiallyZeroRow')]
  [&Category(fcMath)]
  FCN_IsEssentiallyZeroRow = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsDiagonallyDominant')]
  [&Category(fcMath)]
  FCN_IsDiagonallyDominant = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsStrictlyDiagonallyDominant')]
  [&Category(fcMath)]
  FCN_IsStrictlyDiagonallyDominant = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('commute')]
  [&Category(fcMath)]
  FCN_CommutesWith = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToLowerTriangular')]
  [&Category(fcMath)]
  FCN_ToLowerTriangular = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToUpperTriangular')]
  [&Category(fcMath)]
  FCN_ToUpperTriangular = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToUpperHessenberg')]
  [&Category(fcMath)]
  FCN_ToUpperHessenberg = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('HermitianSquare')]
  [&Category(fcMath)]
  FCN_HermitianSquare = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('modulus')]
  [&Category(fcMath)]
  FCN_Modulus = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('determinant', 'det')]
  [&Category(fcMath)]
  FCN_Determinant = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('tr')]
  [&Category(fcMath)]
  FCN_Trace = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('inv')]
  [&Category(fcMath)]
  FCN_Inverse = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('rank')]
  [&Category(fcMath)]
  FCN_Rank = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('nullity')]
  [&Category(fcMath)]
  FCN_Nullity = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ConditionNumber')]
  [&Category(fcMath)]
  FCN_ConditionNumber = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsSingular')]
  [&Category(fcMath)]
  FCN_IsSingular = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DeletedAbsoluteRowSum')]
  [&Category(fcMath)]
  FCN_DeletedAbsoluteRowSum = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RowSwap')]
  [&Category(fcMath)]
  FCN_RowSwap = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RowScale')]
  [&Category(fcMath)]
  FCN_RowScale = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RowAddMul')]
  [&Category(fcMath)]
  FCN_RowAddMul = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RowEchelonForm')]
  [&Category(fcMath)]
  FCN_RowEchelonForm = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReducedRowEchelonForm')]
  [&Category(fcMath)]
  FCN_ReducedRowEchelonForm = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ZeroRowCount')]
  [&Category(fcMath)]
  FCN_NumZeroRows = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TrailingZeroRowCount')]
  [&Category(fcMath)]
  FCN_NumTrailingZeroRows = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GramSchmidt')]
  [&Category(fcMath)]
  FCN_GramSchmidt = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ColumnSpaceBasis')]
  [&Category(fcMath)]
  FCN_ColumnSpaceBasis = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ColumnSpaceProjection')]
  [&Category(fcMath)]
  FCN_ColumnSpaceProjection = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DistanceFromColumnSpace')]
  [&Category(fcMath)]
  FCN_DistanceFromColumnSpace = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('eigenvalues')]
  [&Category(fcMath)]
  FCN_Eigenvalues = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('spectrum')]
  [&Category(fcMath)]
  FCN_Spectrum = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('eigenvectors')]
  [&Category(fcMath)]
  FCN_Eigenvectors = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsEigenvector')]
  [&Category(fcMath)]
  FCN_IsEigenvector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('EigenvalueOf')]
  [&Category(fcMath)]
  FCN_EigenvalueOf = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsEigenpair')]
  [&Category(fcMath)]
  FCN_IsEigenpair = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('EigenvectorOf')]
  [&Category(fcMath)]
  FCN_EigenvectorOf = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SpectralRadius')]
  [&Category(fcMath)]
  FCN_SpectralRadius = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SingularValues')]
  [&Category(fcMath)]
  FCN_SingularValues = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('defuzz')]
  [&Category(fcMath)]
  FCN_Defuzz = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('vectorization', 'vec')]
  [&Category(fcMath)]
  FCN_Vectorization = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('aug')]
  [&Category(fcMath)]
  FCN_Aug = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SubmatrixByRemoval')]
  [&Category(fcMath)]
  FCN_SubmatrixByRemoval = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LeadingPrincipalSubmatrix')]
  [&Category(fcMath)]
  FCN_LeadingPrincipalSubmatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('lessen')]
  [&Category(fcMath)]
  FCN_Lessen = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('minor')]
  [&Category(fcMath)]
  FCN_Minor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('cofactor')]
  [&Category(fcMath)]
  FCN_Cofactor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CofactorMatrix')]
  [&Category(fcMath)]
  FCN_CofactorMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AdjugateMatrix')]
  [&Category(fcMath)]
  FCN_AdjugateMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LU')]
  [&Category(fcMath)]
  FCN_LU = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Cholesky')]
  [&Category(fcMath)]
  FCN_Cholesky = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('QR')]
  [&Category(fcMath)]
  FCN_QR = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('Hessenberg')]
  [&Category(fcMath)]
  FCN_Hessenberg = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SameValue')]
  [&Category(fcGeneral, fcMath)]
  FCN_SameValue = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CompareValue')]
  [&Category(fcGeneral, fcMath)]
  FCN_CompareValue = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ZeroMatrix')]
  [&Category(fcMath)]
  FCN_ZeroMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ComplexZeroMatrix')]
  [&Category(fcMath)]
  FCN_ComplexZeroMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IdentityMatrix')]
  [&Category(fcMath)]
  FCN_IdentityMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReversalMatrix')]
  [&Category(fcMath)]
  FCN_ReversalMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RandomMatrix')]
  [&Category(fcMath)]
  FCN_RandomMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RandomIntMatrix')]
  [&Category(fcMath)]
  FCN_RandomIntMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('OuterProduct')]
  [&Category(fcMath)]
  FCN_OuterProduct = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CirculantMatrix')]
  [&Category(fcMath)]
  FCN_CirculantMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToeplitzMatrix')]
  [&Category(fcMath)]
  FCN_ToeplitzMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('HankelMatrix')]
  [&Category(fcMath)]
  FCN_HankelMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('BackwardShiftMatrix')]
  [&Category(fcMath)]
  FCN_BackwardShiftMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ForwardShiftMatrix')]
  [&Category(fcMath)]
  FCN_ForwardShiftMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('VandermondeMatrix')]
  [&Category(fcMath)]
  FCN_VandermondeMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('HilbertMatrix')]
  [&Category(fcMath)]
  FCN_HilbertMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RotationMatrix')]
  [&Category(fcMath)]
  FCN_RotationMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ReflectionMatrix')]
  [&Category(fcMath)]
  FCN_ReflectionMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('HadamardProduct')]
  [&Category(fcMath)]
  FCN_HadamardProduct = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DirectSum')]
  [&Category(fcMath)]
  FCN_DirectSum = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ForwardSubstitution')]
  [&Category(fcMath)]
  FCN_ForwardSubstitution = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('BackSubstitution')]
  [&Category(fcMath)]
  FCN_BackSubstitution = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SysSolve')]
  [&Category(fcMath)]
  FCN_SysSolve = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LeastSquaresPolynomialFit', 'polyfit')]
  [&Category(fcMath)]
  FCN_LeastSquaresPolynomialFit = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AreParallel')]
  [&Category(fcMath)]
  FCN_AreParallel = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AreNotParallel')]
  [&Category(fcMath)]
  FCN_AreNotParallel = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ArePerpendicular')]
  [&Category(fcMath)]
  FCN_ArePerpendicular = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GetRGB')]
  [&Category(fcPixmaps)]
  FCN_RGBValues = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GetHSV')]
  [&Category(fcPixmaps)]
  FCN_HSVValues = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GetHSL')]
  [&Category(fcPixmaps)]
  FCN_HSLValues = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('color')]
  [&Category(fcPixmaps)]
  FCN_Color = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('HexColorCode')]
  [&Category(fcPixmaps)]
  FCN_HexColorCode = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NamedColors')]
  [&Category(fcPixmaps)]
  FCN_GetNamedColors = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsDark')]
  [&Category(fcPixmaps)]
  FCN_IsDark = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('rgb')]
  [&Category(fcPixmaps)]
  FCN_RGB = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('hsv')]
  [&Category(fcPixmaps)]
  FCN_HSV = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('hsl')]
  [&Category(fcPixmaps)]
  FCN_HSL = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AddMember')]
  [&Category(fcStructures)]
  FCN_AddMember = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RemoveMember')]
  [&Category(fcStructures)]
  FCN_RemoveMember = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetValue')]
  [&Category(fcStructures)]
  FCN_SetValue = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RenameMember')]
  [&Category(fcStructures)]
  FCN_RenameMember = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('HasMember')]
  [&Category(fcStructures)]
  FCN_HasMember = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('IndexOfName')]
  [&Category(fcStructures)]
  FCN_IndexOfName = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('ToStructType')]
  [&Category(fcStructures)]
  FCN_ToStructType = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('new')]
  [&Category(fcStructures)]
  FCN_New = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GetStructType')]
  [&Category(fcStructures)]
  FCN_StructType = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RegisterStructType')]
  [&Category(fcStructures)]
  FCN_RegisterStructType = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('UnregisterStructType')]
  [&Category(fcStructures)]
  FCN_UnregisterStructType = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ValidateStruct')]
  [&Category(fcStructures)]
  FCN_ValidateStruct = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CreatePixmap')]
  [&Category(fcPixmaps)]
  FCN_CreatePixmap = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AddBorder')]
  [&Category(fcPixmaps)]
  FCN_AddBorder = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ExtendBorder')]
  [&Category(fcPixmaps)]
  FCN_ExtendBorder = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ColorFreqs')]
  [&Category(fcPixmaps)]
  FCN_ColorFrequencies = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ColorCount')]
  [&Category(fcPixmaps)]
  FCN_ColorCount = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FillRect')]
  [&Category(fcPixmaps)]
  FCN_FillRect = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DrawRect')]
  [&Category(fcPixmaps)]
  FCN_DrawRect = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AlphaDrawRect')]
  [&Category(fcPixmaps)]
  FCN_AlphaDrawRect = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FixHue')]
  [&Category(fcPixmaps)]
  FCN_FixHue = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToMonochromatic')]
  [&Category(fcPixmaps)]
  FCN_ToMonochromatic = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ShiftHue')]
  [&Category(fcPixmaps)]
  FCN_ShiftHue = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ToGreyscale')]
  [&Category(fcPixmaps)]
  FCN_ToGreyscale = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('InvertColor')]
  [&Category(fcPixmaps)]
  FCN_InvertColor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('InvertValue')]
  [&Category(fcPixmaps)]
  FCN_InvertValue = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('InvertLightness')]
  [&Category(fcPixmaps)]
  FCN_InvertLightness = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AdjustRGB')]
  [&Category(fcPixmaps)]
  FCN_RGBAdjustment = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AdjustHSV')]
  [&Category(fcPixmaps)]
  FCN_HSVAdjustment = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('binarize')]
  [&Category(fcPixmaps)]
  FCN_Binarize = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('flip')]
  [&Category(fcPixmaps)]
  FCN_Flip = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('rot90p')]
  [&Category(fcPixmaps)]
  FCN_Rot90P = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('rot90n')]
  [&Category(fcPixmaps)]
  FCN_Rot90N = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('rot180')]
  [&Category(fcPixmaps)]
  FCN_Rot180 = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ScanlineRotation')]
  [&Category(fcPixmaps)]
  FCN_ScanlineRotation = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CustomScanlineRotation')]
  [&Category(fcPixmaps)]
  FCN_CustomScanlineRotation = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('SkewRotation')]
  [&Category(fcPixmaps)]
  FCN_SkewRotation = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('scale')]
  [&Category(fcPixmaps)]
  FCN_Scale = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('stretch')]
  [&Category(fcPixmaps)]
  FCN_Stretch = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('rotate')]
  [&Category(fcPixmaps)]
  FCN_Rotate = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('shear')]
  [&Category(fcPixmaps)]
  FCN_Shear = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LinearTransformation')]
  [&Category(fcPixmaps)]
  FCN_ApplyLinearTransformation = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('transformation')]
  [&Category(fcPixmaps)]
  FCN_ApplyTransformation = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('GetRect')]
  [&Category(fcPixmaps)]
  FCN_GetRect = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AverageColor')]
  [&Category(fcPixmaps)]
  FCN_AverageColor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AutoCropRect')]
  [&Category(fcPixmaps)]
  FCN_GetAutoCropRect = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AutoCrop')]
  [&Category(fcPixmaps)]
  FCN_AutoCrop = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ExpandCanvas')]
  [&Category(fcPixmaps)]
  FCN_ExpandCanvas = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsOnlyBackground')]
  [&Category(fcPixmaps)]
  FCN_OnlyBackground = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('EdgeDetect')]
  [&Category(fcPixmaps)]
  FCN_DetectEdges = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('emboss')]
  [&Category(fcPixmaps)]
  FCN_Emboss = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('pixelate')]
  [&Category(fcPixmaps)]
  FCN_Pixellate = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('noise')]
  [&Category(fcPixmaps)]
  FCN_Noise = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DistortMetric')]
  [&Category(fcPixmaps)]
  FCN_DistortMetric = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DistortColor')]
  [&Category(fcPixmaps)]
  FCN_DistortColor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('tiles')]
  [&Category(fcPixmaps)]
  FCN_Tiles = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ComponentHighlight')]
  [&Category(fcPixmaps)]
  FCN_ComponentHighlight = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FloodFill')]
  [&Category(fcPixmaps)]
  FCN_FloodFill = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DrawLine')]
  [&Category(fcPixmaps)]
  FCN_DrawLine = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DrawLines')]
  [&Category(fcPixmaps)]
  FCN_DrawLines = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DrawPolygon')]
  [&Category(fcPixmaps)]
  FCN_DrawPolygon = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('convolve')]
  [&Category(fcPixmaps)]
  FCN_Convolve = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ConvolutionKernel')]
  [&Category(fcPixmaps)]
  FCN_ConvolutionKernel = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('MotionBlur')]
  [&Category(fcPixmaps)]
  FCN_MotionBlur = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('BoxBlur')]
  [&Category(fcPixmaps)]
  FCN_BoxBlur = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GaussianBlur')]
  [&Category(fcPixmaps)]
  FCN_GaussianBlur = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('darken')]
  [&Category(fcPixmaps)]
  FCN_Darken = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('whiten')]
  [&Category(fcPixmaps)]
  FCN_Whiten = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FadeToColor')]
  [&Category(fcPixmaps)]
  FCN_FadeToColor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DissolveToColorRegularly')]
  [&Category(fcPixmaps)]
  FCN_EveryOtherToColor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DissolveToColorStochastically')]
  [&Category(fcPixmaps)]
  FCN_RandomToColor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('wind')]
  [&Category(fcPixmaps)]
  FCN_Wind = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RandomScanlineRotation')]
  [&Category(fcPixmaps)]
  FCN_RandomScanlineRotation = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ripple')]
  [&Category(fcPixmaps)]
  FCN_Ripple = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ExtractChannel')]
  [&Category(fcPixmaps, fcSounds)]
  FCN_ExtractChannel = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CombineChannels')]
  [&Category(fcPixmaps)]
  FCN_CombineChannels = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsGreyscale')]
  [&Category(fcPixmaps)]
  FCN_IsGreyscale = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DrawDisk')]
  [&Category(fcPixmaps)]
  FCN_DrawDisk = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DrawDisks')]
  [&Category(fcPixmaps)]
  FCN_DrawDisks = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DrawSquare')]
  [&Category(fcPixmaps)]
  FCN_DrawSquare = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DrawSquares')]
  [&Category(fcPixmaps)]
  FCN_DrawSquares = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ColorGradient')]
  [&Category(fcPixmaps)]
  FCN_CreateGradient = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('voronoi')]
  [&Category(fcPixmaps)]
  FCN_Voronoi = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('superpose')]
  [&Category(fcSounds)]
  FCN_SuperposeSounds = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AppendSound')]
  [&Category(fcSounds)]
  FCN_AppendSound = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('echo')]
  [&Category(fcSounds)]
  FCN_EchoSound = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ScaleAmplitude')]
  [&Category(fcSounds)]
  FCN_SoundScaleAmplitude = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ConvertAudio')]
  [&Category(fcSounds)]
  FCN_SoundConvertTo = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SineTone')]
  [&Category(fcSounds)]
  FCN_SineTone = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('WhiteNoise')]
  [&Category(fcSounds)]
  FCN_WhiteNoise = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('MultichannelAudio')]
  [&Category(fcSounds)]
  FCN_MultichannelSound = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FadeSounds')]
  [&Category(fcSounds)]
  FCN_FadeSounds = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ComputeSound')]
  [&Category(fcSounds)]
  FCN_ComputeSound = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('AudioMetadata')]
  [&Category(fcSounds)]
  FCN_SoundMetadata = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('SoundMax')]
  [&Category(fcSounds)]
  FCN_SoundMax = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('PlaySound')]
  [&Category(fcSounds)]
  FCN_PlaySound = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('StopSound')]
  [&Category(fcSounds)]
  FCN_StopSound = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetInstrument')]
  [&Category(fcMIDI)]
  FCN_SetInstrument = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GetInstrument')]
  [&Category(fcMIDI)]
  FCN_GetInstrument = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SetVolume')]
  [&Category(fcMIDI)]
  FCN_SetVolume = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GetVolume')]
  [&Category(fcMIDI)]
  FCN_GetVolume = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NoteOn')]
  [&Category(fcMIDI)]
  FCN_NoteOn = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NoteOff')]
  [&Category(fcMIDI)]
  FCN_NoteOff = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('PercussionNoteOn')]
  [&Category(fcMIDI)]
  FCN_PNoteOn = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('PercussionNoteOff')]
  [&Category(fcMIDI)]
  FCN_PNoteOff = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NoteSilence')]
  [&Category(fcMIDI)]
  FCN_NoteSilence = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NoteReset')]
  [&Category(fcMIDI)]
  FCN_NoteReset = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('InstrumentInfo')]
  [&Category(fcMIDI)]
  FCN_InstrumentInfo = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('PercussionInstrumentInfo')]
  [&Category(fcMIDI)]
  FCN_PInstrumentInfo = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NoteName')]
  [&Category(fcMIDI)]
  FCN_NoteName = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('MidiMsg')]
  [&Category(fcMIDI)]
  FCN_MidiMsg = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('label')]
  [&Category(fcLists)]
  FCN_LabelList = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('VarAppend')]
  [&Category(fcGeneral, fcLists)]
  FCN_VarAppend = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('VarExtendWith')]
  [&Category(fcGeneral, fcLists)]
  FCN_VarExtendWith = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('catenate', 'concatenate', 'concat')]
  [&Category(fcGeneral, fcLists)]
  FCN_Catenate = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('VarInsert')]
  [&Category(fcGeneral, fcLists)]
  FCN_VarInsert = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('VarRemove')]
  [&Category(fcGeneral, fcLists)]
  FCN_VarRemove = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('VarTruncate')]
  [&Category(fcGeneral, fcLists)]
  FCN_VarTruncate = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('VarSwap')]
  [&Category(fcGeneral, fcLists)]
  FCN_VarSwap = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('numbers')]
  [&Category(fcGeneral, fcLists)]
  FCN_Numbers = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('CreateFunction')]
  [&Category(fcSystem)]
  FCN_CreateFunction = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('image')]
  [&Category(fcSystem)]
  FCN_Image = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IteratedImage')]
  [&Category(fcSystem)]
  FCN_IteratedImage = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IteratedImages')]
  [&Category(fcSystem)]
  FCN_IteratedImages = class(TASSimpleFunction)
  protected
    var
      FContainerClass: TAlgosimObjectClass;
    procedure SimpleFunction; override;
    procedure InitNode; override;
  end;

  [&Function('orbit')]
  [&Category(fcSystem)]
  FCN_Orbit = class(FCN_IteratedImages)
  protected
    procedure InitNode; override;
  end;

  [&Function('IsNumber')]
  [&Category(fcSystem)]
  FCN_IsNumber = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsVector')]
  [&Category(fcSystem)]
  FCN_IsVector = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsMatrix')]
  [&Category(fcSystem)]
  FCN_IsMatrix = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsText')]
  [&Category(fcSystem)]
  FCN_IsText = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsBoolean')]
  [&Category(fcSystem)]
  FCN_IsBoolean = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsPixmap')]
  [&Category(fcSystem)]
  FCN_IsPixmap = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsSound')]
  [&Category(fcSystem)]
  FCN_IsSound = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsTable')]
  [&Category(fcSystem)]
  FCN_IsTable = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsColor')]
  [&Category(fcSystem)]
  FCN_IsColor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsSet')]
  [&Category(fcSystem)]
  FCN_IsSet = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsList')]
  [&Category(fcSystem)]
  FCN_IsList = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsStructure')]
  [&Category(fcSystem)]
  FCN_IsStructure = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsReal')]
  [&Category(fcSystem)]
  FCN_IsReal = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsComplex')]
  [&Category(fcSystem)]
  FCN_IsComplex = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsInteger')]
  [&Category(fcSystem)]
  FCN_IsInteger = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsNumericEntity')]
  [&Category(fcSystem)]
  FCN_IsNumericEntity = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsNumericArray')]
  [&Category(fcSystem)]
  FCN_IsNumericArray = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsBinaryData')]
  [&Category(fcSystem)]
  FCN_IsBinaryData = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('entrywise')]
  [&Category(fcLists, fcMath)]
  FCN_entrywise = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('accumulate')]
  [&Category(fcGeneral, fcLists, fcMath)]
  FCN_Accumulate = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AccumulateList')]
  [&Category(fcGeneral, fcLists, fcMath)]
  FCN_AccumulateList = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AccumulateSteps')]
  [&Category(fcGeneral, fcLists, fcMath)]
  FCN_AccumulateSteps = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('rest')]
  [&Category(fcGeneral, fcLists)]
  FCN_Rest = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('append')]
  [&Category(fcGeneral, fcLists)]
  FCN_Append = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ExtendWith')]
  [&Category(fcGeneral, fcLists)]
  FCN_ExtendWith = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('insert')]
  [&Category(fcGeneral, fcLists)]
  FCN_Insert = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('remove')]
  [&Category(fcGeneral, fcLists)]
  FCN_Remove = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('truncate')]
  [&Category(fcGeneral, fcLists)]
  FCN_Truncate = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('swap')]
  [&Category(fcGeneral, fcLists)]
  FCN_Swap = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SortBy')]
  [&Category(fcGeneral, fcLists)]
  FCN_SortBy = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('member')]
  [&Category(fcStructures)]
  FCN_Member = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('GroupBy')]
  [&Category(fcGeneral, fcLists)]
  FCN_GroupBy = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('characters')]
  [&Category(fcStrings)]
  FCN_Characters = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('words')]
  [&Category(fcStrings)]
  FCN_Words = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('do')]
  [&Category(fcSystem)]
  FCN_Do = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('divides')]
  [&Category(fcMath)]
  FCN_Divides = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('NotDivides')]
  [&Category(fcMath)]
  FCN_NotDivides = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('primorial')]
  [&Category(fcMath)]
  FCN_Primorial = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('inc')]
  [&Category(fcMath)]
  FCN_Inc = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('dec')]
  [&Category(fcMath)]
  FCN_Dec = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('variables')]
  [&Category(fcSystem)]
  FCN_Variables = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LastError')]
  [&Category(fcSystem)]
  FCN_LastError = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('functions')]
  [&Category(fcSystem)]
  FCN_Functions = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  TKernelFunctionFcn = class abstract(TASSimpleFunction)
  protected
    procedure SimpleFunction; override; final;
    procedure Fcn(AFcnClass: TASFunctionClass); virtual; abstract;
  end;

  [&Function('function')]
  [&Category(fcSystem)]
  FCN_Function = class(TKernelFunctionFcn)
  protected
    procedure Fcn(AFcnClass: TASFunctionClass); override;
  end;

  [&Function('categories')]
  [&Category(fcSystem)]
  FCN_Categories = class(TKernelFunctionFcn)
  protected
    procedure Fcn(AFcnClass: TASFunctionClass); override;
  end;

  [&Function('FcnName')]
  [&Category(fcSystem)]
  FCN_FcnName = class(TKernelFunctionFcn)
  protected
    procedure Fcn(AFcnClass: TASFunctionClass); override;
  end;

  [&Function('FcnNames')]
  [&Category(fcSystem)]
  FCN_FcnNames = class(TKernelFunctionFcn)
  protected
    procedure Fcn(AFcnClass: TASFunctionClass); override;
  end;

  [&Function('ErrorInfo')]
  [&Category(fcSystem)]
  FCN_ErrorInfo = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('succ')]
  [&Category(fcMath)]
  FCN_Succ = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('pred')]
  [&Category(fcMath)]
  FCN_Pred = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LoadDefVars')]
  [&Category(fcSystem)]
  FCN_LoadDefVars = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('operators')]
  [&Category(fcSystem)]
  FCN_Operators = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('if')]
  [&Category(fcSystem)]
  FCN_If = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('ForEach')]
  [&Category(fcGeneral, fcLists, fcStrings, fcStructures, fcSets)]
  FCN_ForEach = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('print')]
  [&Category(fcSystem)]
  FCN_Print = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RemoveBuffer')]
  [&Category(fcSystem)]
  FCN_RemoveBuffer = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('BufferText')]
  [&Category(fcSystem)]
  FCN_BufferText = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('buffers')]
  [&Category(fcSystem)]
  FCN_Buffers = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('MessageBox')]
  [&Category(fcSystem)]
  FCN_MessageBox = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('InputBox')]
  [&Category(fcSystem)]
  FCN_InputBox = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FormatDateTime')]
  [&Category(fcDateTime)]
  FCN_FormatDateTime = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DateTimeString')]
  [&Category(fcDateTime)]
  FCN_DateTimeString = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DateString')]
  [&Category(fcDateTime)]
  FCN_DateString = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TimeString')]
  [&Category(fcDateTime)]
  FCN_TimeString = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('while')]
  [&Category(fcSystem)]
  FCN_While = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('until')]
  [&Category(fcSystem)]
  FCN_Until = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('repeat')]
  [&Category(fcSystem)]
  FCN_Repeat = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('for')]
  [&Category(fcSystem)]
  FCN_For = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('tokenize')]
  [&Category(fcSystem)]
  FCN_Tokenize = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('parse')]
  [&Category(fcSystem)]
  FCN_Parse = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('WordWrap')]
  [&Category(fcStrings)]
  FCN_WordWrap = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('history')]
  [&Category(fcSystem)]
  FCN_History = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('input')]
  [&Category(fcSystem)]
  FCN_Input = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('inputs')]
  [&Category(fcSystem)]
  FCN_Inputs = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('output')]
  [&Category(fcSystem)]
  FCN_Output = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('HistoryLength')]
  [&Category(fcSystem)]
  FCN_HistoryLength = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ClearHistory')]
  [&Category(fcSystem)]
  FCN_ClearHistory = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SaveHistory')]
  [&Category(fcSystem)]
  FCN_SaveHistory = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SelfTest')]
  [&Category(fcSystem)]
  FCN_SelfTest = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('bases')]
  [&Category(fcSystem)]
  FCN_Bases = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FcnExpr')]
  [&Category(fcSystem)]
  FCN_FcnExpr = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RandomColor')]
  [&Category(fcPixmaps)]
  FCN_RandomColor = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('compute')]
  [&Category(fcLists, fcMath, fcGeneral)]
  FCN_Compute = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('DebugObject')]
  [&Category(fcSystem)]
  FCN_DebugObject = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CompareString')]
  [&Category(fcStrings)]
  FCN_CompareString = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsCharacter')]
  [&Category(fcSystem)]
  FCN_IsCharacter = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsRealType')]
  [&Category(fcSystem)]
  FCN_IsRealType = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsComplexType')]
  [&Category(fcSystem)]
  FCN_IsComplexType = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('break')]
  [&Category(fcSystem)]
  FCN_Break = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('continue')]
  [&Category(fcSystem)]
  FCN_Continue = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SquareWave')]
  [&Category(fcMath)]
  FCN_SquareWave = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('TriangleWave')]
  [&Category(fcMath)]
  FCN_TriangleWave = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('SawtoothWave')]
  [&Category(fcMath)]
  FCN_SawtoothWave = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('BlendModes')]
  [&Category(fcPixmaps)]
  FCN_BlendModes = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  TNamedObjFcn = class abstract(TASFunction)
  protected
    procedure DoExecute; override; final;
    procedure HandleNamedObject(AObject: TAlgosimObject; const AName: string);
      virtual; abstract;
  end;

  [&Function('display')]
  [&Category(fcSystem)]
  FCN_Display = class(TNamedObjFcn)
  protected
    procedure HandleNamedObject(AObject: TAlgosimObject; const AName: string);
      override;
  end;

  [&Function('window')]
  [&Category(fcSystem)]
  FCN_Window = class(TNamedObjFcn)
  protected
    procedure HandleNamedObject(AObject: TAlgosimObject; const AName: string);
      override;
  end;

  [&Function('ComputePixmap')]
  [&Category(fcPixmaps)]
  FCN_ComputePixmap = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('ColorDialog')]
  [&Category(fcSystem)]
  FCN_ColorDialog = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FontDialog')]
  [&Category(fcSystem)]
  FCN_FontDialog = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FileExists')]
  [&Category(fcSystem)]
  FCN_FileExists = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FileSize')]
  [&Category(fcSystem)]
  FCN_FileSize = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FileName')]
  [&Category(fcSystem)]
  FCN_FileName = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('PrettyFileName')]
  [&Category(fcSystem)]
  FCN_PrettyFileName = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FilePath')]
  [&Category(fcSystem)]
  FCN_FilePath = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FileExt')]
  [&Category(fcSystem)]
  FCN_FileExt = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DeleteFile')]
  [&Category(fcSystem)]
  FCN_DeleteFile = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CreateDirectory')]
  [&Category(fcSystem)]
  FCN_CreateDirectory = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DeleteDirectory')]
  [&Category(fcSystem)]
  FCN_DeleteDirectory = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DirectoryExists')]
  [&Category(fcSystem)]
  FCN_DirectoryExists = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FileList')]
  [&Category(fcSystem)]
  FCN_FileList = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('DirectoryList')]
  [&Category(fcSystem)]
  FCN_DirectoryList = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FileOpenDialog')]
  [&Category(fcSystem)]
  FCN_FileOpenDialog = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FileSaveDialog')]
  [&Category(fcSystem)]
  FCN_FileSaveDialog = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('IsCarolNumber')]
  [&Category(fcMath, fcNumberTheory)]
  FCN_IsCarolNumber = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('StructKeys')]
  [&Category(fcSystem)]
  FCN_StructKeys = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('digits')]
  [&Category(fcSystem)]
  FCN_Digits = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('FractionParts')]
  [&Category(fcSystem)]
  FCN_FractionParts = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ExampleData')]
  [&Category(fcGeneral)]
  FCN_ExampleData = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LeftAlign')]
  [&Category(fcTables)]
  FCN_LeftAlign = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RightAlign')]
  [&Category(fcTables)]
  FCN_RightAlign = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('CenterText')]
  [&Category(fcTables)]
  FCN_CenterText = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('MatrixPlot')]
  [&Category(fcMath, fcPixmaps)]
  FCN_MatrixPlot = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('diagram')]
  [&Category(fcVisualization)]
  FCN_Diagram = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  TASVisualizationFunction = class(TASSimpleFunction)
  strict protected
    FVisual: TObject;
    procedure SimpleFunction; override;
  public
    destructor Destroy; override;
  end;

  [&Function('BarChart')]
  [&Category(fcVisualization)]
  FCN_BarChart = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('PieChart')]
  [&Category(fcVisualization)]
  FCN_PieChart = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('histogram')]
  [&Category(fcVisualization)]
  FCN_Histogram = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('ScatterPlot')]
  [&Category(fcVisualization)]
  FCN_ScatterPlot = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LineChart', 'LinePlot')]
  [&Category(fcVisualization)]
  FCN_LineChart = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AreaChart')]
  [&Category(fcVisualization)]
  FCN_AreaChart = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('graph')]
  [&Category(fcSystem, fcVisualization)]
  FCN_Graph = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('plot')]
  [&Category(fcVisualization)]
  FCN_Plot = class(TASFunction)
  protected
    procedure DoExecute; override;
  end;

  [&Function('heatmap')]
  [&Category(fcVisualization)]
  FCN_Heatmap = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('VectorField')]
  [&Category(fcVisualization)]
  FCN_VectorField = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('RemoveVisual')]
  [&Category(fcVisualization)]
  FCN_RemoveVisual = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('AdjustVisual')]
  [&Category(fcVisualization)]
  FCN_AdjustVisual = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('LineSegment')]
  [&Category(fcVisualization)]
  FCN_LineSegment = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('rectangle')]
  [&Category(fcVisualization)]
  FCN_Rectangle = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('circle')]
  [&Category(fcVisualization)]
  FCN_Circle = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('disk')]
  [&Category(fcVisualization)]
  FCN_Disk = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('polygon')]
  [&Category(fcVisualization)]
  FCN_Polygon = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('text')]
  [&Category(fcVisualization)]
  FCN_Text = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('EmbedPixmap')]
  [&Category(fcPixmaps, fcVisualization)]
  FCN_EmbedPixmap = class(TASVisualizationFunction)
  protected
    procedure SimpleFunction; override;
  end;

  [&Function('speak')]
  [&Category(fcSystem)]
  FCN_Speak = class(TASSimpleFunction)
  protected
    procedure SimpleFunction; override;
  end;



var
  FixedTime: TDateTime;

implementation

uses
  Windows, Math, StrUtils, DateUtils, ASPropMan, ASPropStores, ASStrFcns,
  UnicodeData, ASTable, ASColors, ASPixmap, ASSounds, ASMIDI, ASTokenizer,
  ASParser, SyncObjs, IOUtils, ASNumUtils, ASVisualization, VisCtl2D, ASSpeech;

const
  DefPlotN = 2000;

function GetCurDate: TDateTime;
begin
  if FixedTime <> 0.0 then
    Result := DateOf(FixedTime)
  else
    Result := SysUtils.Date
end;

function GetCurTime: TDateTime;
begin
  if FixedTime <> 0.0 then
    Result := TimeOf(FixedTime)
  else
    Result := SysUtils.Time
end;

function GetCurDateTime: TDateTime;
begin
  if FixedTime <> 0.0 then
    Result := FixedTime
  else
    Result := SysUtils.Now
end;

function GetYesterday: TDateTime;
begin
  if FixedTime <> 0.0 then
    Result := GetCurDate - 1 // mimics the implementation of DateUtils.Yesterday
  else
    Result := DateUtils.Yesterday
end;

function GetTomorrow: TDateTime;
begin
  if FixedTime <> 0.0 then
    Result := GetCurDate + 1 // mimics the implementation of DateUtils.Tomorrow
  else
    Result := DateUtils.Tomorrow;
end;


{ FCN_Identity }

procedure FCN_Identity.SimpleFunction;
begin
  Args.MoveObject(Value).Close;
end;

{ FCN_Add }

procedure FCN_Add.SimpleFunction;
var
  Args: TArgumentExtractor;
  Right: TAlgosimObject;
begin

  Args := Self.Args;

  if Args.Count = 0 then
  begin
    Result := ASO(0);
    Exit;
  end;

  Args := Args.MoveObject(Value);

  while Args.ArgExists do
  begin

    Args := Args.Extract(Right);

    if (Value is TAlgosimNumber) and (Right is TAlgosimNumber) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimNumber.Add(TAlgosimNumber(Value), TAlgosimNumber(Right)))

    else if (Value is TAlgosimVector) and (Right is TAlgosimVector) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimVector.Add(TAlgosimVector(Value), TAlgosimVector(Right)))

    else if (Value is TAlgosimMatrix) and (Right is TAlgosimMatrix) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimMatrix.Add(TAlgosimMatrix(Value), TAlgosimMatrix(Right)))

    else if (Value is TAlgosimString) and (Right is TAlgosimString) then
      TObjReplacer<TAlgosimObject>.Replace(Value, ASO(TAlgosimString(Value).Value + TAlgosimString(Right).Value))

    else if Value is TAlgosimString then
      TObjReplacer<TAlgosimObject>.Replace(Value, ASO(TAlgosimString(Value).Value + Right.GetAsSingleLineText(Context.FormatOptions)))

    else if (Value is TAlgosimVector) and (Right is TAlgosimNumber) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimVector.Add(TAlgosimVector(Value), TAlgosimNumber(Right)))

    else if (Value is TAlgosimMatrix) and (Right is TAlgosimNumber) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimMatrix.Add(TAlgosimMatrix(Value), TAlgosimNumber(Right)))

    else if (Value is TAlgosimSound) and (Right is TAlgosimSound) then
      TObjReplacer<TAlgosimObject>.Replace(Value, ASO(TAlgosimSound(Value).Value + TAlgosimSound(Right).Value))

    else
      ErrInvalidArguments;

  end;

end;

{ FCN_Subtract }

procedure FCN_Subtract.SimpleFunction;
var
  Left, Right: TAlgosimObject;
begin

  Args.Extract(Left).Extract(Right).Close;

  if (Left is TAlgosimNumber) and (Right is TAlgosimNumber) then
    Result := TAlgosimNumber.Subtract(TAlgosimNumber(Left), TAlgosimNumber(Right))

  else if (Left is TAlgosimVector) and (Right is TAlgosimVector) then
    Result := TAlgosimVector.Subtract(TAlgosimVector(Left), TAlgosimVector(Right))

  else if (Left is TAlgosimMatrix) and (Right is TAlgosimMatrix) then
    Result := TAlgosimMatrix.Subtract(TAlgosimMatrix(Left), TAlgosimMatrix(Right))

  else if (Left is TAlgosimVector) and (Right is TAlgosimNumber) then
    Result := TAlgosimVector.Subtract(TAlgosimVector(Left), TAlgosimNumber(Right))

  else if (Left is TAlgosimMatrix) and (Right is TAlgosimNumber) then
    Result := TAlgosimMatrix.Subtract(TAlgosimMatrix(Left), TAlgosimNumber(Right))

  else if (Left is TAlgosimSound) and (Right is TAlgosimSound) then
    Result := ASO(TAlgosimSound(Left).Value - TAlgosimSound(Right).Value)

  else
    ErrInvalidArguments;

end;

{ FCN_UnaryMinus }

procedure FCN_UnaryMinus.SimpleFunction;
var
  Obj: TAlgosimObject;
begin
  Args.Extract(Obj).Close;
  Result := Obj.UnaryMinus;
end;

{ FCN_Multiply }

procedure FCN_Multiply.SimpleFunction;
var
  Args: TArgumentExtractor;
  Right: TAlgosimObject;
  IntVal: Integer;
  RealVal: TASR;
begin

  Args := Self.Args;

  if Args.Count = 0 then
  begin
    Result := ASO(1);
    Exit;
  end;

  Args := Args.MoveObject(Value);

  while Args.ArgExists do
  begin

    Args := Args.Extract(Right);

    if (Value is TAlgosimNumber) and (Right is TAlgosimNumber) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimNumber.Multiply(TAlgosimNumber(Value), TAlgosimNumber(Right)))

    else if (Value is TAlgosimVector) and (Right is TAlgosimVector) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimVector.InnerProduct(TAlgosimVector(Value), TAlgosimVector(Right)))

    else if (Value is TAlgosimMatrix) and (Right is TAlgosimMatrix) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimMatrix.Multiply(TAlgosimMatrix(Value), TAlgosimMatrix(Right)))

    else if (Value is TAlgosimNumber) and (Right is TAlgosimVector) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimVector.Multiply(TAlgosimVector(Right), TAlgosimNumber(Value)))

    else if (Value is TAlgosimVector) and (Right is TAlgosimNumber) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimVector.Multiply(TAlgosimVector(Value), TAlgosimNumber(Right)))

    else if (Value is TAlgosimNumber) and (Right is TAlgosimMatrix) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimMatrix.Multiply(TAlgosimMatrix(Right), TAlgosimNumber(Value)))

    else if (Value is TAlgosimMatrix) and (Right is TAlgosimNumber) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimMatrix.Multiply(TAlgosimMatrix(Value), TAlgosimNumber(Right)))

    else if (Value is TAlgosimMatrix) and (Right is TAlgosimVector) then
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimMatrix.Multiply(TAlgosimMatrix(Value), TAlgosimVector(Right)))

    else if (Right is TAlgosimString) and (Value is TAlgosimNumber) and Value.TryToInt32(IntVal) and (IntVal >= 0) then
      TObjReplacer<TAlgosimObject>.Replace(Value, ASO(DupeString(TAlgosimString(Right).Value, IntVal)))

    else if (Value is TAlgosimString) and (Right is TAlgosimNumber) and Right.TryToInt32(IntVal) and (IntVal >= 0) then
      TObjReplacer<TAlgosimObject>.Replace(Value, ASO(DupeString(TAlgosimString(Value).Value, IntVal)))

    else if (Right is TAlgosimSound) and (Value is TAlgosimNumber) and Value.TryToASR(RealVal) then
      TObjReplacer<TAlgosimObject>.Replace(Value, ASO(RealVal * TAlgosimSound(Right).Value))

    else if (Value is TAlgosimSound) and (Right is TAlgosimSound) then
      TObjReplacer<TAlgosimObject>.Replace(Value, ASO(TAlgosimSound(Value).Value * TAlgosimSound(Right).Value))

    else
      ErrInvalidArguments;

  end;

end;

{ FCN_InnerProduct }

procedure FCN_InnerProduct.SimpleFunction;
var
  L, R: TAlgosimVector;
begin
  Args.Extract(L).Extract(R).Close;
  Result := TAlgosimVector.InnerProduct(L, R);
end;

{ FCN_Divide }

procedure FCN_Divide.SimpleFunction;
var
  Left, Right: TAlgosimObject;
begin

  Args.Extract(Left).Extract(Right).Close;

  if (Left is TAlgosimNumber) and (Right is TAlgosimNumber) then
    Result := TAlgosimNumber.Divide(TAlgosimNumber(Left), TAlgosimNumber(Right))

  else if (Left is TAlgosimVector) and (Right is TAlgosimNumber) then
    Result := TAlgosimVector.Divide(TAlgosimVector(Left), TAlgosimNumber(Right))

  else if (Left is TAlgosimMatrix) and (Right is TAlgosimNumber) then
    Result := TAlgosimMatrix.Divide(TAlgosimMatrix(Left), TAlgosimNumber(Right))

  else
    ErrInvalidArguments;

end;

{ FCN_Power }

procedure FCN_Power.SimpleFunction;
var
  Left, Right: TAlgosimObject;
  IntVal: Integer;
begin

  Args.Extract(Left).Extract(Right).Close;

  if (Left is TAlgosimNumber) and (Right is TAlgosimNumber) then
    Result := TAlgosimNumber.Power(TAlgosimNumber(Left), TAlgosimNumber(Right))

  else if (Left is TAlgosimMatrix) and (Right is TAlgosimNumber) and Right.TryToInt32(IntVal) then
    Result := TAlgosimMatrix(Left).Power(IntVal)

  else
    ErrInvalidArguments;

end;

{ FCN_Cross }

procedure FCN_Cross.SimpleFunction;
var
  Args: TArgumentExtractor;
  Right: TAlgosimVector;
  U, V: TAlgosimSet;
  sets: array of TAlgosimSet;
  i: Integer;
begin
  Args := Self.Args;
  if Args.PeekAt(0) is TAlgosimVector then
  begin
    Args := Args.MoveObject(Value);
    while Args.ArgExists do
    begin
      Args := Args.Extract(Right);
      TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimVector.CrossProduct(TAlgosimVector(Value), Right))
    end;
  end
  else
  begin
    if Args.Count = 2 then // because it might be slightly faster
    begin
      Args.Extract(U).Extract(V).Close;
      Result := TAlgosimSet.CartesianProduct(U, V);
    end
    else
    begin
      SetLength(sets, Args.Count);
      for i := 0 to Args.Count - 1 do
        Args := Args.Extract(sets[i]);
      Result := TAlgosimSet.CartesianProduct(sets);
    end;
  end;
end;

{ FCN_CrossProduct }

procedure FCN_CrossProduct.SimpleFunction;
var
  Right: TAlgosimVector;
  Args: TArgumentExtractor;
begin
  Args := Self.Args.MoveObject<TAlgosimVector>(Value);
  while Args.ArgExists do
  begin
    Args := Args.Extract(Right);
    TObjReplacer<TAlgosimObject>.Replace(Value, TAlgosimVector.CrossProduct(TAlgosimVector(Value), Right))
  end;
end;


{ FCN_Angle }

procedure FCN_Angle.SimpleFunction;
var
  Left, Right: TAlgosimVector;
begin
  Args.Extract(Left).Extract(Right).Close;
  Result := TAlgosimVector.Angle(Left, Right);
end;

{ FCN_Factorial }

procedure FCN_Factorial.SimpleFunction;
var
  N: Integer;
begin
  Args.ExtractNonNeg(N).Close;
  if InRange(N, Low(intfactorials), High(intfactorials)) then
    Result := ASOInt(intfactorials[N])
  else
    Result := ASO(factorial(N));
end;

{ FCN_Modulus }

procedure FCN_Absolute.SimpleFunction;
var
  Arg: TAlgosimNumericEntity;
begin
  Args.Extract(Arg).Close;
  Result := Arg.Abs;
end;

{ FCN_ConjugateTranspose }

procedure FCN_ConjugateTranspose.SimpleFunction;
var
  Arg: TAlgosimNumericEntity;
begin
  Args.Extract(Arg).Close;
  if Arg is TAlgosimNumber then
    Result := TAlgosimNumber(Arg).Conjugate
  else
    Result := Arg.ConjugateTranspose;
end;

{ FCN_Transpose }

procedure FCN_Transpose.SimpleFunction;
var
  Arg: TAlgosimObject;
begin

  Args.Extract(Arg).Close;

  if Arg is TAlgosimNumericEntity then
    Result := TAlgosimNumericEntity(Arg).Transpose

  else if Arg is TAlgosimArray then
    Result := TAlgosimArray(Arg).Transpose

  else
    ErrInvalidArguments;

end;

{ FCN_Argument }

procedure FCN_Argument.SimpleFunction;
var
  Arg: TAlgosimNumber;
begin
  Args.Extract(Arg).Close;
  Result := Arg.Argument;
end;

{ FCN_RealPart }

procedure FCN_RealPart.SimpleFunction;
var
  Arg: TAlgosimNumericEntity;
begin
  Args.Extract(Arg).Close;
  Result := Arg.RealPart;
end;

{ FCN_ImaginaryPart }

procedure FCN_ImaginaryPart.SimpleFunction;
var
  Arg: TAlgosimNumericEntity;
begin
  Args.Extract(Arg).Close;
  Result := Arg.ImaginaryPart;
end;

{ FCN_sqrt }

procedure FCN_Sqrt.SimpleFunction;
const
  rdom_sqrt: TSDD = (a: 0; Kind: sddGeq; Complement: False);
var
  Arg: TAlgosimNumericEntity;
begin

  Args.Extract(Arg).Close;

  if Arg is TAlgosimNumber then
    Result := TAlgosimNumber(Arg).ComputeFunction(rdom_sqrt, sqrt, csqrt)

  else if Arg is TAlgosimMatrix then
  begin
    if Arg is TAlgosimRealMatrix then
      Result := ASO(sqrt(TAlgosimRealMatrix(Arg).Value))
    else if Arg is TAlgosimComplexMatrix then
      Result := ASO(sqrt(TAlgosimComplexMatrix(Arg).Value));
  end

  else
    ErrInvalidArguments;

end;

{ FCN_Deg }

class constructor FCN_Deg.ClassCreate;
begin
  PiDiv180 := ASO(Pi / 180);
end;

class destructor FCN_Deg.ClassDestroy;
begin
  FreeAndNil(PiDiv180);
end;

procedure FCN_Deg.SimpleFunction;
var
  Arg: TAlgosimNumber;
begin
  Args.Extract(Arg).Close;
  Result := TAlgosimNumber.Multiply(Arg, PiDiv180);
end;

{ FCN_Percent }

class constructor FCN_Percent.ClassCreate;
begin
  OneHundredth := ASO(1 / 100);
end;

class destructor FCN_Percent.ClassDestroy;
begin
  FreeAndNil(OneHundredth);
end;

procedure FCN_Percent.SimpleFunction;
var
  Arg: TAlgosimNumber;
begin
  Args.Extract(Arg).Close;
  Result := TAlgosimNumber.Multiply(Arg, OneHundredth);
end;

{ FCN_Permille }

class constructor FCN_Permille.ClassCreate;
begin
  OneThousandth := ASO(1 / 1000);
end;

class destructor FCN_Permille.ClassDestroy;
begin
  FreeAndNil(OneThousandth);
end;

procedure FCN_Permille.SimpleFunction;
var
  Arg: TAlgosimNumber;
begin
  Args.Extract(Arg).Close;
  Result := TAlgosimNumber.Multiply(Arg, OneThousandth);
end;

{ FCN_Square }

procedure FCN_Square.SimpleFunction;
var
  Arg: TAlgosimNumericEntity;
begin
  Args.Extract(Arg).Close;
  Result := Arg.Square;
end;

{ FCN_sin }

procedure FCN_sin.InitNode;
begin
  rfcn := sin;
  cfcn := csin;
end;

{ FCN_cos }

procedure FCN_cos.InitNode;
begin
  rfcn := cos;
  cfcn := ccos;
end;

{ FCN_tan }

procedure FCN_tan.InitNode;
begin
  rfcn := tan;
  cfcn := ctan;
end;

{ FCN_cot }

procedure FCN_cot.InitNode;
begin
  rfcn := cot;
  cfcn := ccot;
end;

{ FCN_sec }

procedure FCN_sec.InitNode;
begin
  rfcn := sec;
  cfcn := csec;
end;

{ FCN_csc }

procedure FCN_csc.InitNode;
begin
  rfcn := csc;
  cfcn := ccsc;
end;

{ FCN_arcsin }

procedure FCN_arcsin.InitNode;
const
  rdom_arcsin: TSDD = (a: -1; b: 1; Kind: sddBii; Complement: False);
begin
  inherited;
  rfcn := arcsin;
  cfcn := carcsin;
  rdom := rdom_arcsin;
end;

{ FCN_arccos }

procedure FCN_arccos.InitNode;
const
  rdom_arccos: TSDD = (a: -1; b: 1; Kind: sddBii; Complement: False);
begin
  inherited;
  rfcn := arccos;
  cfcn := carccos;
  rdom := rdom_arccos;
end;

{ FCN_arctan }

procedure FCN_arctan.InitNode;
begin
  rfcn := arctan;
  cfcn := carctan;
end;

{ FCN_arccot }

procedure FCN_arccot.InitNode;
begin
  rfcn := arccot;
  cfcn := carccot;
end;

{ FCN_arcsec }

procedure FCN_arcsec.InitNode;
const
  rdom_arcsec: TSDD = (a: -1; b: 1; Kind: sddBee; Complement: True);
begin
  rfcn := arcsec;
  cfcn := carcsec;
  rdom := rdom_arcsec;
end;

{ FCN_arccsc }

procedure FCN_arccsc.InitNode;
const
  rdom_arccsc: TSDD = (a: -1; b: 1; Kind: sddBee; Complement: True);
begin
  rfcn := arccsc;
  cfcn := carccsc;
  rdom := rdom_arccsc;
end;

{ FCN_sinh }

procedure FCN_sinh.InitNode;
begin
  rfcn := sinh;
  cfcn := csinh;
end;

{ FCN_cosh }

procedure FCN_cosh.InitNode;
begin
  rfcn := cosh;
  cfcn := ccosh;
end;

{ FCN_tanh }

procedure FCN_tanh.InitNode;
begin
  rfcn := Math.tanh;
  cfcn := ctanh;
end;

{ FCN_coth }

procedure FCN_coth.InitNode;
begin
  rfcn := Math.coth;
  cfcn := ccoth;
end;

{ FCN_sech }

procedure FCN_sech.InitNode;
begin
  rfcn := ASNum.sech;
  cfcn := csech;
end;

{ FCN_csch }

procedure FCN_csch.InitNode;
begin
  rfcn := ASNum.csch;
  cfcn := ccsch;
end;

{ FCN_arcsinh }

procedure FCN_arcsinh.InitNode;
begin
  rfcn := ASNum.arcsinh;
  cfcn := carcsinh;
end;

{ FCN_arccosh }

procedure FCN_arccosh.InitNode;
const
  rdom_arccosh: TSDD = (a: 1; Kind: sddGeq; Complement: False);
begin
  inherited;
  rfcn := arccosh;
  cfcn := carccosh;
  rdom := rdom_arccosh;
end;

{ FCN_arctanh }

procedure FCN_arctanh.InitNode;
const
  rdom_arctanh: TSDD = (a: -1; b: 1; Kind: sddBee; Complement: False);
begin
  inherited;
  rfcn := arctanh;
  cfcn := carctanh;
  rdom := rdom_arctanh;
end;

{ FCN_arccoth }

procedure FCN_arccoth.InitNode;
const
  rdom_arccoth: TSDD = (a: -1; b: 1; Kind: sddBii; Complement: True);
begin
  inherited;
  rfcn := arccoth;
  cfcn := carccoth;
  rdom := rdom_arccoth;
end;

{ FCN_arcsech }

procedure FCN_arcsech.InitNode;
const
  rdom_arcsech: TSDD = (a: 0; b: 1; Kind: sddBei; Complement: False);
begin
  inherited;
  rfcn := arcsech;
  cfcn := carcsech;
  rdom := rdom_arcsech;
end;

{ FCN_arccsch }

procedure FCN_arccsch.InitNode;
begin
  rfcn := ASNum.arccsch;
  cfcn := carccsch;
end;

{ FCN_sinc }

procedure FCN_sinc.InitNode;
begin
  rfcn := sinc;
  cfcn := csinc;
end;

{ FCN_exp }

procedure FCN_exp.InitNode;
begin
  rfcn := exp;
  cfcn := cexp;
end;

{ FCN_ln }

procedure FCN_ln.InitNode;
const
  rdom_ln: TSDD = (a: 0; Kind: sddGt; Complement: False);
begin
  inherited;
  rfcn := ln;
  cfcn := cln;
  rdom := rdom_ln;
end;

{ FCN_log }

procedure FCN_log.InitNode;
const
  rdom_ln: TSDD = (a: 0; Kind: sddGt; Complement: False);
begin
  inherited;
  rfcn := Log10;
  cfcn := clog;
  rdom := rdom_ln;
end;

{ FCN_Floor }

procedure FCN_Floor.SimpleFunction;
var
  X: TASR;
begin
  inherited;
  Args.Extract(X).Close;
  Result := ASOInt(ASNum.Floor64(X));
end;

{ FCN_Ceil }

procedure FCN_Ceil.SimpleFunction;
var
  X: TASR;
begin
  Args.Extract(X).Close;
  Result := ASOInt(ASNum.Ceil64(X));
end;

{ FCN_Round }

procedure FCN_Round.SimpleFunction;
var
  X: TASR;
begin
  Args.Extract(X).Close;
  Result := ASOInt(Round(X));
end;

{ FCN_Trunc }

procedure FCN_Trunc.SimpleFunction;
var
  X: TASR;
begin
  Args.Extract(X).Close;
  Result := ASOInt(Trunc(X));
end;

{ FCN_Frac }

procedure FCN_Frac.InitNode;
begin
  rfcn := frac;
end;

{ FCN_Sgn }

procedure FCN_Sgn.SimpleFunction;
var
  x: TASR;
  z: TASC;
begin
  if Args.PeekAt(0) is TAlgosimComplexNumber then
  begin
    Args.Extract(z).Close;
    Result := ASO(csign(z));
  end
  else
  begin
    Args.Extract(x).Close;
    Result := ASOInt(Sign(x));
  end;
end;

{ FCN_mod }

procedure FCN_mod.SimpleFunction;
var
  A, B: TASI;
  X, Y: TASR;
begin
  if (Args.PeekAt(0) is TAlgosimInteger) and (Args.PeekAt(1) is TAlgosimInteger) then
  begin
    Args.Extract(A).Extract(B).Close;
    Result := ASOInt(ASNum.imod(A, B));
  end
  else
  begin
    Args.Extract(X).Extract(Y).Close;
    Result := ASO(ASNum.rmod(X, Y));
  end;
end;

{ FCN_lcm }

procedure FCN_lcm.SimpleFunction;
var
  Vals: TArray<Int64>;
begin
  Vals := Args.ExtractInt64s;
  Result := ASOInt(ASNum.lcm(Vals));
end;

{ FCN_gcd }

procedure FCN_gcd.SimpleFunction;
var
  Vals: TArray<Int64>;
begin
  Vals := Args.ExtractInt64s;
  Result := ASOInt(ASNum.gcd(Vals));
end;

{ FCN_combinations }

procedure FCN_combinations.SimpleFunction;
var
  n, k: Integer;
  res: TASI;
begin
  Args.Extract(n).Extract(k).Close;
  res := intcombinations(n, k);
  if res <> 0 then
    Result := ASOInt(res)
  else
    Result := ASO(combinations(n, k));
end;

{ FCN_permutations }

procedure FCN_permutations.SimpleFunction;
var
  n, k: Integer;
  res: TASI;
begin
  Args.Extract(n).Extract(k).Close;
  res := intpermutations(n, k);
  if res <> 0 then
    Result := ASOInt(res)
  else
    Result := ASO(permutations(n, k));
end;

{ FCN_IsPrime }

procedure FCN_IsPrime.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := ASO(ASNum.IsPrime(Arg));
end;

{ FCN_NextPrime }

procedure FCN_NextPrime.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := ASOInt(ASNum.NextPrime(Arg));
end;

{ FCN_PrevPrime }

procedure FCN_PrevPrime.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := ASOInt(ASNum.PreviousPrime(Arg));
end;

{ FCN_NthPrime }

procedure FCN_NthPrime.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  if Arg < 0 then
    Arg := 0
  else if Arg > Integer.MaxValue then
  begin
    Result := ASO(failure, 'Cannot test integers this large for primality.');
    Exit;
  end;
  Result := ASOInt(ASNum.NthPrime(Integer(Arg)));
end;

{ FCN_PrimePi }

procedure FCN_PrimePi.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  if Arg < 0 then
    Result := ASOInt(0)
  else if Arg > Integer.MaxValue then
    Result := ASO(failure, 'Cannot test integers this large for primality.')
  else
    Result := ASOInt(ASNum.PrimePi(Arg));
end;

{ FCN_Fibonacci }

procedure FCN_Fibonacci.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  if InRange(Arg, Low(IntFibonaccis), High(IntFibonaccis)) then
    Result := ASOInt(IntFibonaccis[Arg])
  else
    Result := ASO(ASNum.Fibonacci(Arg));
end;

{ FCN_Lucas }

procedure FCN_Lucas.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  if InRange(Arg, Low(IntLucas), High(IntLucas)) then
    Result := ASOInt(IntLucas[Arg])
  else
    Result := ASO(ASNum.Lucas(Arg));
end;

{ FCN_MöbiusMu }

procedure FCN_MöbiusMu.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := ASOInt(ASNum.MöbiusMu(Arg));
end;

{ FCN_Mertens }

procedure FCN_Mertens.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := ASOInt(ASNum.Mertens(Arg));
end;

{ FCN_AreCoprime }

procedure FCN_AreCoprime.SimpleFunction;
var
  Arg1, Arg2: TASI;
begin
  Args.Extract(Arg1).Extract(Arg2).Close;
  Result := ASO(ASNum.coprime(Arg1, Arg2));
end;

{ FCN_Iverson }

procedure FCN_Iverson.SimpleFunction;
var
  Arg: Boolean;
begin
  Args.Extract(Arg).Close;
  Result := ASOInt(ASNum.IversonBracket(Arg));
end;

{ FCN_Kronecker }

procedure FCN_Kronecker.SimpleFunction;
var
  Arg1, Arg2: TASI;
begin
  Args.Extract(Arg1).Extract(Arg2).Close;
  Result := ASOInt(ASNum.KroneckerDelta(Arg1, Arg2));
end;

{ FCN_LegendreSymbol }

procedure FCN_LegendreSymbol.SimpleFunction;
var
  Arg1, Arg2: TASI;
begin
  Args.Extract(Arg1).Extract(Arg2).Close;
  Result := ASOInt(ASNum.LegendreSymbol(Arg1, Arg2));
end;

{ FCN_JacobiSymbol }

procedure FCN_JacobiSymbol.SimpleFunction;
var
  Arg1, Arg2: TASI;
begin
  Args.Extract(Arg1).Extract(Arg2).Close;
  Result := ASOInt(ASNum.JacobiSymbol(Arg1, Arg2));
end;

{ FCN_KroneckerSymbol }

procedure FCN_KroneckerSymbol.SimpleFunction;
var
  Arg1, Arg2: TASI;
begin
  Args.Extract(Arg1).Extract(Arg2).Close;
  Result := ASOInt(ASNum.KroneckerSymbol(Arg1, Arg2));
end;

{ FCN_totient }

procedure FCN_totient.SimpleFunction;
var
  Arg: Integer;
begin
  Args.Extract(Arg).Close;
  Result := ASOInt(ASNum.totient(Arg));
end;

{ FCN_cototient }

procedure FCN_cototient.SimpleFunction;
var
  Arg: Integer;
begin
  Args.Extract(Arg).Close;
  Result := ASOInt(ASNum.cototient(Arg));
end;

{ FCN_PrimeFactors }

procedure FCN_PrimeFactors.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := TAlgosimArray.CreateWithValue(ASNum.PrimeFactors(Arg));
end;

{ FCN_Radical }

procedure FCN_Radical.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := ASOInt(ASNum.Radical(Arg));
end;

{ FCN_IsSquareFree }

procedure FCN_IsSquareFree.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := ASO(ASNum.IsSquareFree(Arg));
end;

{ FCN_Factorize }

procedure FCN_Factorize.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := TAlgosimArray.CreateWithValue(ASNum.factorize(Arg));
end;

{ FCN_FactorizedExpression }

procedure FCN_FactorizedExpression.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := ASO(ASNum.GetFactorizedString(Arg, True));
end;

{ FCN_Divisors }

procedure FCN_Divisors.SimpleFunction;
var
  Arg: TASI;
begin
  Args.Extract(Arg).Close;
  Result := TAlgosimArray.CreateWithValue(ASNum.divisors(Arg));
end;

{ FCN_ContinuedFraction }

procedure FCN_ContinuedFraction.SimpleFunction;
var
  Arg: TAlgosimObject;
  maxlen: Integer;
  cf: TArray<TASI>;
begin

  Args.Extract(Arg).ExtractPos(maxlen, 18).Close;
  if Arg is TAlgosimRationalNumber then
    cf := ASNum.ContinuedFraction(TAlgosimRationalNumber(Arg).Value)
  else if stRationalNumber.MatchingName(Arg) then
    cf := ASNum.ContinuedFraction(ASOToRationalNumber(TAlgosimTypedStructure(Arg)))
  else if Arg is TAlgosimInteger then
    cf := [Arg.ToASI]
  else if Arg is TAlgosimNumber then
    cf := ASNum.ContinuedFraction(Arg.ToASR, maxlen)
  else
    ErrInvalidArguments;

  if Length(cf) > maxlen then
    SetLength(cf, maxlen);

  Result := TAlgosimArray.CreateWithValue(cf);

end;

{ FCN_ToFraction }

procedure FCN_ToFraction.SimpleFunction;
var
  RatParts: TAlgosimTypedStructure;
  Num: TAlgosimNumber;
  CF: TArray<TASI>;
begin

  if (Args.Count <= 1) and not (Args.PeekAt(0) is TAlgosimArray) then
  begin
    if Args.PeekAt(0) is TAlgosimStructure then
    begin
      Args.Extract(RatParts, stRationalNumber);
      Result := ASORat(ASOToRationalNumber(RatParts));
    end
    else
    begin
      Args.Extract(Num);
      Result := ASORat(Num.ToRat);
    end;
  end

  else
  begin
    CF := Args.ExtractInt64s;
    Result := ASORat(ASNum.ContinuedFractionToFraction(CF));
  end;

  if Result is TAlgosimRationalNumber then
  begin
    TAlgosimRationalNumber(Result).NumberFormat := nfFraction;
    TAlgosimRationalNumber(Result).NumberFormatOverride := True;
  end;

end;

{ FCN_ToSymbolicForm }

procedure FCN_ToSymbolicForm.SimpleFunction;
resourcestring
  SNoCloseEnoughSymbolicFormFound = 'No close enough symbolic form found.';

  function GetStr(const AValue: TASR): string;
  var
    SSF: TSimpleSymbolicForm;
  begin
    SSF := ASNum.ToSymbolicForm(AValue);
    if SSF.valid then
      Result := SSF.ToString(Context.FormatOptions)
    else
      Result := SNoCloseEnoughSymbolicFormFound;
  end;

var
  Arg: TAlgosimNumber;
  z: TASC;
begin
  Args.Extract(Arg).Close;
  if Arg.IsComplex then
  begin
    z := Arg.ToASC;
    Result := TAlgosimStructure.CreateWithValue(
      ['Re', 'Im'],
      [ASO(GetStr(z.Re)), ASO(GetStr(z.Im))]
    );
  end
  else
    Result := ASO(GetStr(Arg.ToASR));
end;

{ FCN_erf }

procedure FCN_erf.InitNode;
begin
  rfcn := ASNum.erf;
end;

{ FCN_cerf }

procedure FCN_erfc.InitNode;
begin
  rfcn := ASNum.erfc;
end;

{ FCN_FresnelC }

procedure FCN_FresnelC.InitNode;
begin
  rfcn := ASNum.FresnelC;
end;

{ FCN_FresnelS }

procedure FCN_FresnelS.InitNode;
begin
  rfcn := ASNum.FresnelS;
end;

{ FCN_Si }

procedure FCN_Si.InitNode;
begin
  rfcn := ASNum.Si;
end;

{ FCN_Ci }

procedure FCN_Ci.InitNode;
begin
  rfcn := ASNum.Ci;
end;

{ FCN_Bessel }

procedure FCN_Bessel.SimpleFunction;
var
  N: Integer;
  Arg: TAlgosimNumber;
begin

  Args.Extract(N).Extract(Arg).Close;

  if Arg.IsComplex then
    Result := ASO(ASNum.Bessel(N, Arg.ToASC))
  else
    Result := ASO(ASNum.Bessel(N, Arg.ToASR));

end;

{ FCN_Laguerre }

procedure FCN_Laguerre.SimpleFunction;
var
  N: Integer;
  Arg: TAlgosimNumber;
begin

  Args.Extract(N).Extract(Arg).Close;

  if Arg.IsComplex then
    Result := ASO(ASNum.Laguerre(N, Arg.ToASC))
  else
    Result := ASO(ASNum.Laguerre(N, ARg.ToASR));

end;

{ FCN_Hermite }

procedure FCN_Hermite.SimpleFunction;
var
  N: Integer;
  Arg: TAlgosimNumber;
begin

  Args.Extract(N).Extract(Arg).Close;

  if Arg.IsComplex then
    Result := ASO(ASNum.Hermite(N, Arg.ToASC))
  else
    Result := ASO(ASNum.Hermite(N, Arg.ToASR));

end;

{ FCN_Legendre }

procedure FCN_Legendre.SimpleFunction;
var
  N: Integer;
  Arg: TAlgosimNumber;
begin

  Args.Extract(N).Extract(Arg).Close;

  if Arg.IsComplex then
    Result := ASO(ASNum.Legendre(N, Arg.ToASC))
  else
    Result := ASO(ASNum.Legendre(N, Arg.ToASR));

end;

{ FCN_GammaFunction }

procedure FCN_GammaFunction.InitNode;
begin
  rfcn := ASNum.GammaFunction;
  cfcn := ASNum.GammaFunction;
end;

{ FCN_Chebyshev }

procedure FCN_Chebyshev.SimpleFunction;
var
  N: Integer;
  Arg: TAlgosimNumber;
begin

  Args.Extract(N).Extract(Arg).Close;

  if Arg.IsComplex then
    Result := ASO(ASNum.Chebyshev(N, Arg.ToASC))
  else
    Result := ASO(ASNum.Chebyshev(N, Arg.ToASR));

end;

{ FCN_Bernstein }

procedure FCN_Bernstein.SimpleFunction;
var
  I, N: Integer;
  Arg: TAlgosimNumber;
begin

  Args.Extract(I).Extract(N).Extract(Arg).Close;

  if Arg.IsComplex then
    Result := ASO(ASNum.Bernstein(I, N, Arg.ToASC))
  else
    Result := ASO(ASNum.Bernstein(I, N, Arg.ToASR));

end;

{ FCN_HarmonicNumber }

procedure FCN_HarmonicNumber.SimpleFunction;
var
  Arg: TAlgosimNumber;
  IntVal: TASI;
  X: TASR;
begin
  Args.Extract(Arg).Close;
  if Arg.TryToASI(IntVal) then
    Result := ASO(ASNum.HarmonicNumber(IntVal))
  else
  begin
    X := Arg.ToASR;
    if X > TASI.MaxValue then
      Result := ASO(EulerMascheroni + Ln(X))
    else
      ErrInvalidArguments;
  end;
end;

{ FCN_And }

procedure FCN_And.DoBitwise;
var
  i: Integer;
  Res, Operand: TAlgosimInteger;
begin
  if not EvalChildren(1) then Exit; // 0 already evaluated
  Res := TAlgosimInteger.Create(Children[0].Value);
  Value := Res;
  for i := 1 to ChildCount - 1 do
  begin
    Extract<TAlgosimInteger>(i, Operand);
    Res.Value := Res.Value and Operand.Value;
  end;
end;

procedure FCN_And.DoExecute;
var
  i, h: Integer;
  Operand: TAlgosimBoolean;
begin

  h := Args.Count - 1;

  for i := 0 to h do
  begin

    if not EvalChild(i) then Exit;

    // Bitwise?
    if (i = 0) and (Args.PeekAt(0) is TAlgosimInteger) then
    begin
      DoBitwise;
      Exit;
    end;

    Extract<TAlgosimBoolean>(i, Operand);

    if not Operand.Value or (i = h) then
    begin
      TMover<TAlgosimObject>.Move(Value, Children[i].Value);
      Exit;
    end;

  end;

  Result := ASO(True);

end;

{ FCN_Or }

procedure FCN_Or.DoBitwise;
var
  i: Integer;
  Res, Operand: TAlgosimInteger;
begin
  if not EvalChildren(1) then Exit; // 0 already evaluated
  Res := TAlgosimInteger.Create(Children[0].Value);
  Value := Res;
  for i := 1 to ChildCount - 1 do
  begin
    Extract<TAlgosimInteger>(i, Operand);
    Res.Value := Res.Value or Operand.Value;
  end;
end;

procedure FCN_Or.DoExecute;
var
  i, h: Integer;
  Operand: TAlgosimBoolean;
begin

  h := Args.Count - 1;

  for i := 0 to h do
  begin

    if not EvalChild(i) then Exit;

    // Bitwise?
    if (i = 0) and (Args.PeekAt(0) is TAlgosimInteger) then
    begin
      DoBitwise;
      Exit;
    end;

    Extract<TAlgosimBoolean>(i, Operand);

    if Operand.Value or (i = h) then
    begin
      TMover<TAlgosimObject>.Move(Value, Children[i].Value);
      Exit;
    end;

  end;

  Result := ASO(False);

end;

{ FCN_Not }

procedure FCN_Not.SimpleFunction;
var
  Arg: Boolean;
  IntArg: TASI;
begin
  if Args.PeekAt(0) is TAlgosimInteger then
  begin
    Args.Extract(IntArg).Close;
    Result := ASOInt(not IntArg);
    Exit;
  end;
  Args.Extract(Arg).Close;
  Result := ASO(not Arg);
end;

{ FCN_Xor }

procedure FCN_Xor.SimpleFunction;
var
  Left, Right: Boolean;
  LInt, RInt: TASI;
begin
  // Bitwise?
  if Args.PeekAt(0) is TAlgosimInteger then
  begin
    Args.Extract(LInt).Extract(RInt).Close;
    Result := ASOInt(LInt xor RInt);
    Exit;
  end;
  Args.Extract(Left).Extract(Right).Close;
  Result := ASO(Left xor Right);
end;

{ FCN_Nand }

procedure FCN_Nand.SimpleFunction;
var
  Left, Right: Boolean;
begin
  Args.Extract(Left).Extract(Right).Close;
  Result := ASO(not (Left and Right));
end;

{ FCN_Nor }

procedure FCN_Nor.SimpleFunction;
var
  Left, Right: Boolean;
begin
  Args.Extract(Left).Extract(Right).Close;
  Result := ASO(not (Left or Right));
end;

{ FCN_ImpliesRight }

procedure FCN_ImpliesRight.SimpleFunction;
var
  Left, Right: Boolean;
begin
  Args.Extract(Left).Extract(Right).Close;
  Result := ASO(not Left or Right);
end;

{ FCN_ImpliesLeft }

procedure FCN_ImpliesLeft.SimpleFunction;
var
  Left, Right: Boolean;
begin
  Args.Extract(Left).Extract(Right).Close;
  Result := ASO(not Right or Left);
end;

{ FCN_Equivalent }

procedure FCN_Equivalent.SimpleFunction;
var
  Left, Right: Boolean;
begin
  Args.Extract(Left).Extract(Right).Close;
  Result := ASO(Left = Right);
end;

{ FCN_Equals }

procedure FCN_Equals.SimpleFunction;
var
  Arg1, Arg2: TAlgosimObject;
  LArgs: TArgumentExtractor;
  PrevObj, Obj: TAlgosimObject;
begin

  if Args.Count <> 2 then
  begin
    LArgs := Self.Args;
    if LArgs.ArgExists then
      LArgs := LArgs.Extract(PrevObj);
    while LArgs.ArgExists do
    begin
      LArgs := LArgs.Extract(Obj);
      if not PrevObj.Equals(Obj) then
      begin
        Result := ASO(False);
        Exit;
      end;
      PrevObj := Obj;
    end;
    Result := ASO(True);
    Exit;
  end;

  Args.Extract(Arg1).Extract(Arg2).Close;
  Result := ASO(Arg1.Equals(Arg2));

end;

{ FCN_NotEquals }

procedure FCN_NotEquals.SimpleFunction;
var
  Arg1, Arg2: TAlgosimObject;
begin
  Args.Extract(Arg1).Extract(Arg2).Close;
  Result := ASO(not Arg1.Equals(Arg2));
end;

{ FCN_LessThan }

procedure FCN_LessThan.SimpleFunction;
var
  Arg1, Arg2: TAlgosimObject;
  LArgs: TArgumentExtractor;
  PrevNum, Num: TAlgosimNumber;
begin

  if Args.Count <> 2 then
  begin
    LArgs := Self.Args;
    if LArgs.ArgExists then
      LArgs := LArgs.Extract(PrevNum);
    while LArgs.ArgExists do
    begin
      LArgs := LArgs.Extract(Num);
      if not TAlgosimNumber.LessThan(PrevNum, Num) then
      begin
        Result := ASO(False);
        Exit;
      end;
      PrevNum := Num;
    end;
    Result := ASO(True);
    Exit;
  end;

  Args.Extract(Arg1).Extract(Arg2).Close;

  if (Arg1 is TAlgosimNumber) and (Arg2 is TAlgosimNumber) then
    Result := ASO(TAlgosimNumber.LessThan(TAlgosimNumber(Arg1), TAlgosimNumber(Arg2)))

  else if (Arg1 is TAlgosimRealVector) and (Arg2 is TAlgosimRealVector) then
    Result := ASO(TAlgosimRealVector(Arg1).Value < TAlgosimRealVector(Arg2).Value)

  else if (Arg1 is TAlgosimRealMatrix) and (Arg2 is TAlgosimRealMatrix) then
    Result := ASO(TAlgosimRealMatrix(Arg1).Value < TAlgosimRealMatrix(Arg2).Value)

  else if IsTypedStructure(Arg1, [stDate, stDateTime]) and IsTypedStructure(Arg2, [stDate, stDateTime]) then
    Result :=
      ASO(
        CompareDateTime(
          ASOToDateTime(Arg1),
          ASOToDateTime(Arg2)
        ) = LessThanValue
      )

  else
    ErrInvalidArguments;

end;

{ FCN_LessThanOrEqualTo }

procedure FCN_LessThanOrEqualTo.SimpleFunction;
var
  Arg1, Arg2: TAlgosimObject;
  LArgs: TArgumentExtractor;
  PrevNum, Num: TAlgosimNumber;
begin

  if Args.Count <> 2 then
  begin
    LArgs := Self.Args;
    if LArgs.ArgExists then
      LArgs := LArgs.Extract(PrevNum);
    while LArgs.ArgExists do
    begin
      LArgs := LArgs.Extract(Num);
      if not TAlgosimNumber.LessThanOrEqualTo(PrevNum, Num) then
      begin
        Result := ASO(False);
        Exit;
      end;
      PrevNum := Num;
    end;
    Result := ASO(True);
    Exit;
  end;

  Args.Extract(Arg1).Extract(Arg2).Close;

  if (Arg1 is TAlgosimNumber) and (Arg2 is TAlgosimNumber) then
    Result := ASO(TAlgosimNumber.LessThanOrEqualTo(TAlgosimNumber(Arg1), TAlgosimNumber(Arg2)))

  else if (Arg1 is TAlgosimRealVector) and (Arg2 is TAlgosimRealVector) then
    Result := ASO(TAlgosimRealVector(Arg1).Value <= TAlgosimRealVector(Arg2).Value)

  else if (Arg1 is TAlgosimRealMatrix) and (Arg2 is TAlgosimRealMatrix) then
    Result := ASO(TAlgosimRealMatrix(Arg1).Value <= TAlgosimRealMatrix(Arg2).Value)

  else if IsTypedStructure(Arg1, [stDate, stDateTime]) and IsTypedStructure(Arg2, [stDate, stDateTime]) then
    Result :=
      ASO(
        CompareDateTime(
          ASOToDateTime(Arg1),
          ASOToDateTime(Arg2)
        ) <= EqualsValue
      )

  else
    ErrInvalidArguments;

end;

{ FCN_GreaterThan }

procedure FCN_GreaterThan.SimpleFunction;
var
  Arg1, Arg2: TAlgosimObject;
  IntVal: Integer;
  LArgs: TArgumentExtractor;
  PrevNum, Num: TAlgosimNumber;
begin

  if Args.Count <> 2 then
  begin
    LArgs := Self.Args;
    if LArgs.ArgExists then
      LArgs := LArgs.Extract(PrevNum);
    while LArgs.ArgExists do
    begin
      LArgs := LArgs.Extract(Num);
      if not TAlgosimNumber.GreaterThan(PrevNum, Num) then
      begin
        Result := ASO(False);
        Exit;
      end;
      PrevNum := Num;
    end;
    Result := ASO(True);
    Exit;
  end;

  Args.Extract(Arg1).Extract(Arg2).Close;

  if (Arg1 is TAlgosimNumber) and (Arg2 is TAlgosimNumber) then
    Result := ASO(TAlgosimNumber.GreaterThan(TAlgosimNumber(Arg1), TAlgosimNumber(Arg2)))

  else if (Arg1 is TAlgosimRealVector) and (Arg2 is TAlgosimRealVector) then
    Result := ASO(TAlgosimRealVector(Arg1).Value > TAlgosimRealVector(Arg2).Value)

  else if (Arg1 is TAlgosimRealVector) and (Arg2 is TAlgosimNumber) and Arg2.TryToInt32(IntVal) and (IntVal = 0) then
    Result := ASO(TAlgosimRealVector(Arg1).Value.IsPositive)

  else if (Arg1 is TAlgosimRealMatrix) and (Arg2 is TAlgosimRealMatrix) then
    Result := ASO(TAlgosimRealMatrix(Arg1).Value > TAlgosimRealMatrix(Arg2).Value)

  else if (Arg1 is TAlgosimRealMatrix) and (Arg2 is TAlgosimNumber) and Arg2.TryToInt32(IntVal) and (IntVal = 0) then
    Result := ASO(TAlgosimRealMatrix(Arg1).Value.IsPositive)

  else if IsTypedStructure(Arg1, [stDate, stDateTime]) and IsTypedStructure(Arg2, [stDate, stDateTime]) then
    Result :=
      ASO(
        CompareDateTime(
          ASOToDateTime(Arg1),
          ASOToDateTime(Arg2)
        ) = GreaterThanValue
      )

  else
    ErrInvalidArguments;

end;

{ FCN_GreaterThanOrEqualTo }

procedure FCN_GreaterThanOrEqualTo.SimpleFunction;
var
  Arg1, Arg2: TAlgosimObject;
  IntVal: Integer;
  LArgs: TArgumentExtractor;
  PrevNum, Num: TAlgosimNumber;
begin

  if Args.Count <> 2 then
  begin
    LArgs := Self.Args;
    if LArgs.ArgExists then
      LArgs := LArgs.Extract(PrevNum);
    while LArgs.ArgExists do
    begin
      LArgs := LArgs.Extract(Num);
      if not TAlgosimNumber.GreaterThanOrEqualTo(PrevNum, Num) then
      begin
        Result := ASO(False);
        Exit;
      end;
      PrevNum := Num;
    end;
    Result := ASO(True);
    Exit;
  end;

  Args.Extract(Arg1).Extract(Arg2).Close;

  if (Arg1 is TAlgosimNumber) and (Arg2 is TAlgosimNumber) then
    Result := ASO(TAlgosimNumber.GreaterThanOrEqualTo(TAlgosimNumber(Arg1), TAlgosimNumber(Arg2)))

  else if (Arg1 is TAlgosimRealVector) and (Arg2 is TAlgosimRealVector) then
    Result := ASO(TAlgosimRealVector(Arg1).Value >= TAlgosimRealVector(Arg2).Value)

  else if (Arg1 is TAlgosimRealVector) and (Arg2 is TAlgosimNumber) and Arg2.TryToInt32(IntVal) and (IntVal = 0) then
    Result := ASO(TAlgosimRealVector(Arg1).Value.IsNonNegative)

  else if (Arg1 is TAlgosimRealMatrix) and (Arg2 is TAlgosimRealMatrix) then
    Result := ASO(TAlgosimRealMatrix(Arg1).Value >= TAlgosimRealMatrix(Arg2).Value)

  else if (Arg1 is TAlgosimRealMatrix) and (Arg2 is TAlgosimNumber) and Arg2.TryToInt32(IntVal) and (IntVal = 0) then
    Result := ASO(TAlgosimRealMatrix(Arg1).Value.IsNonNegative)

  else if IsTypedStructure(Arg1, [stDate, stDateTime]) and IsTypedStructure(Arg2, [stDate, stDateTime]) then
    Result :=
      ASO(
        CompareDateTime(
          ASOToDateTime(Arg1),
          ASOToDateTime(Arg2)
        ) >= EqualsValue
      )

  else
    ErrInvalidArguments;

end;

{ FCN_Dim }

procedure FCN_Dim.DoExecute;
var
  Arg: TAlgosimVector;
begin
  CheckNumArgs(1);
  if not ExtractRef<TAlgosimVector>(0, Arg) then Exit;
  Result := ASOInt(Arg.Dimension);
end;

{ FCN_Size }

procedure FCN_Size.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASOSize(Arg.PlanarExtent);
end;

{ FCN_Width }

procedure FCN_Width.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASOInt(Arg.PlanarExtent.cx);
end;

{ FCN_Height }

procedure FCN_Height.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASOInt(Arg.PlanarExtent.cy);
end;

{ FCN_Subscript }

function FCN_Subscript.BuildLValue(LValueData: TLValueData): Boolean;
var
  i: Integer;
begin
  Result := ChildCount >= 2;
  if Result then
  begin
    for i := 1 to ChildCount - 1 do
    begin
      Children[i].Evaluate;
      if IsControl(Children[i].Value) then
        Exit(False);
    end;
    if ChildCount = 2 then
      LValueData.Add(TLValuePathItem.Create(Children[1].Value))
    else
    begin
      // emulate an array of integers, so you can write A[1, 2] instead of A['(1, 2)]
      FreeAndNil(FEquivArray);
      FEquivArray := TAlgosimArray.Create;
      for i := 1 to ChildCount - 1 do
        FEquivArray.Add(Children[i].Value.Clone);
      LValueData.Add(TLValuePathItem.Create(FEquivArray));
    end;
    Result := Children[0].BuildLValue(LValueData);
  end;
end;

destructor FCN_Subscript.Destroy;
begin
  FreeAndNil(FEquivArray);
  inherited;
end;

procedure FCN_subscript.DoExecute;
var
  Obj, Idx: TAlgosimObject;
begin
  CheckNumArgsAtLeast(2);
  if not ExtractRef(0, Obj) then Exit;
  if not EvalChildren(1) then Exit;
  if Args.Count = 2 then
  begin
    Args.Skip.Extract(Idx);
    Result := Obj.GetSubscriptedValue(TSubscript.Create(Idx));
  end
  else
  begin
    // emulate an array of integers, so you can write A[1, 2] instead of A['(1, 2)]
    Idx := TAlgosimArray.CreateWithValue(Args.Skip.ExtractInt64s);
    try
      Result := Obj.GetSubscriptedValue(TSubscript.Create(Idx));
    finally
      Idx.Free;
    end;
  end;
end;

function FCN_Subscript.LValuePart: Boolean;
begin
  Result := True;
end;

{ FCN_AccessMember }

function FCN_AccessMember.BuildLValue(LValueData: TLValueData): Boolean;
begin
  Result := (ChildCount = 2) and IsSymbol(Children[1]);
  if Result then
  begin
    LValueData.Add(TLValuePathItem.Create(TASSymbolExprNode(Children[1]).Symbol));
    Result := Children[0].BuildLValue(LValueData);
  end;
end;

procedure FCN_AccessMember.DoExecute;
var
  Struct: TAlgosimStructure;
  MbrName: string;
begin

  CheckNumArgs(2);

  if not TryLValueFetch then
  begin
    if not EvalChild(0) then Exit;
    CheckSymbol(1);
    Args.Extract(Struct);
    MbrName := TASSymbolExprNode(Children[1]).Symbol;
    Result := Struct[MbrName];
    Struct.Release(MbrName);
  end;

end;

function FCN_AccessMember.LValuePart: Boolean;
begin
  Result := True;
end;

{ FCN_norm }

procedure FCN_Norm.SimpleFunction;
var
  Arg: TAlgosimNumericEntity;
  Kind: string;
  Param: Integer;
begin
  Args.Extract(Arg).Extract(Kind, 'Euclidean').Extract(Param, 2).Close;
  Result := ASO(Arg.Norm(TNormType.FromString(Kind), Param, QuitPauseCheck));
end;

{ FCN_NormSquared }

procedure FCN_NormSquared.SimpleFunction;
var
  Arg: TAlgosimNumericEntity;
begin
  Args.Extract(Arg).Close;
  Result := Arg.NormSquared;
end;

{ FCN_Normalized }

procedure FCN_Normalized.SimpleFunction;
var
  Arg: TAlgosimVector;
begin
  Args.Extract(Arg).Close;
  Result := Arg.NormalizedIfNonzero;
end;

{ FCN_First }

function FCN_First.BuildLValue(LValueData: TLValueData): Boolean;
begin
  Result := ChildCount = 1;
  if Result then
  begin
    LValueData.Add(TLValuePathItem.Create(skFirst));
    Result := Children[0].BuildLValue(LValueData);
  end;
end;

procedure FCN_First.DoExecute;
var
  Obj: TAlgosimObject;
  N: Integer;
begin

  CheckNumArgs([1, 2]);

  if Args.Count = 1 then
  begin
    if not ExtractRef(0, Obj) then Exit;
    Result := Obj.Values[1];
  end
  else
  begin
    if not EvalChild(1) then Exit;
    Args.Skip.ExtractNonNeg(N).Close;

    if TryExtractStoreRef(0, Obj) then
      Result := Obj.First(N) // don't modify!
    else
    begin
      if not EvalChild(0) then Exit;
      if Args.PeekAt(0).IsPlanarContainer then
        Result := Args.PeekAt(0).First(N)
      else
      begin
        Args.MoveObject(Value);
        Value.Truncate(N);
      end;
    end;
  end;

end;

function FCN_First.LValuePart: Boolean;
begin
  Result := True;
end;

{ FCN_Last }

function FCN_Last.BuildLValue(LValueData: TLValueData): Boolean;
begin
  Result := ChildCount = 1;
  if Result then
  begin
    LValueData.Add(TLValuePathItem.Create(skLast));
    Result := Children[0].BuildLValue(LValueData);
  end;
end;

procedure FCN_Last.DoExecute;
var
  Obj: TAlgosimObject;
  N: Integer;
begin

  CheckNumArgs([1, 2]);

  if Args.Count = 1 then
  begin
    if not ExtractRef(0, Obj) then Exit;
    Result := Obj.Values[-1];
  end
  else
  begin
    if not EvalChild(1) then Exit;
    Args.Skip.ExtractNonNeg(N).Close;

    if TryExtractStoreRef(0, Obj) then
      Result := Obj.Last(N) // don't modify!
    else
    begin
      if not EvalChild(0) then Exit;
      if Args.PeekAt(0).IsPlanarContainer then
        Result := Args.PeekAt(0).Last(N)
      else
      begin
        Args.MoveObject(Value);
        Value.RemoveFirst(Value.ValueCount - N);
      end;
    end;
  end;

end;

function FCN_Last.LValuePart: Boolean;
begin
  Result := True;
end;

{ FCN_Part }

procedure FCN_Part.DoExecute;
var
  Obj: TAlgosimObject;
  Ranges, Ranges2: TArray<TRange>;
begin

  CheckNumArgs([2, 3]);
  if not ExtractRef(0, Obj) then Exit;
  if not EvalChildren(1) then Exit;

  case Args.Count - 1 of
    1:
      begin
        Args.Skip.Extract(Ranges).Close;
        Result := Obj.Part(Ranges)
      end;
    2:
      begin
        Args.Skip.Extract(Ranges).Extract(Ranges2).Close;
        Result := Obj.Part2d(Ranges, Ranges2);
      end;
  else
    ErrInvalidArguments;
  end;

end;

{ FCN_Range }

procedure FCN_Range.SimpleFunction;
var
  From, &To, Step: Integer;
begin
  Args.Extract(From).Extract(&To, From).Extract(Step, 1).Close;
  Result := ASOIntRange(From, &To, Step);
end;

{ FCN_Sort }

procedure FCN_Sort.ChooseComparer(const AStr: string);
begin
  if AStr = 'standard order' then
    rcmp := TASRComparer.StandardOrder
  else if AStr = 'standard order descending' then
    rcmp := TASRComparer.StandardOrderDescending
  else if AStr = 'absolute value' then
    rcmp := TASRComparer.AbsoluteValue
  else if AStr = 'absolute value descending' then
    rcmp := TASRComparer.AbsoluteValueDescending
  else if AStr = 'real and imaginary parts' then
    ccmp := TASCComparer.ReIm
  else if AStr = 'real and imaginary parts descending' then
    ccmp := TASCComparer.ReImDescending
  else if AStr = 'modulus' then
    ccmp := TASCComparer.Modulus
  else if AStr = 'modulus descending' then
    ccmp := TASCComparer.ModulusDescending
  else if AStr = 'argument' then
    ccmp := TASCComparer.Argument
  else if AStr = 'argument descending' then
    ccmp := TASCComparer.ArgumentDescending
  else if AStr = 'modulus argument' then
    ccmp := TASCComparer.ModulusArgument
  else if AStr = 'modulus argument descending' then
    ccmp := TASCComparer.ModulusArgumentDescending
  else
    raise EInvArgs.CreateFmt(SUnknownComparer, [AStr]);
end;

procedure FCN_Sort.SimpleFunction;
var
  CmpName: string;
begin
  Args.MoveObject(Value).Extract(CmpName, '').Close;
  if CmpName.IsEmpty then
  begin
    if asoComplex in Value.ClassFlags then
      raise Exception.Create('No comparison method specified.')
    else
      Value.Sort
  end
  else
  begin
    ChooseComparer(CmpName.ToLower);
    if Assigned(ccmp) then
      Value.Sort(ccmp)
    else if Assigned(rcmp) then
      Value.Sort(rcmp)
    else
      ErrInternal;
  end;
end;

{ FCN_CustomSort }

procedure FCN_CustomSort.DoExecute;
var
  SymLeft, SymRight: TList<TASExprNode>;
begin

  CheckNumArgs(2);

  if not EvalChild(0) then Exit;
  Args.MoveObject(Value);

  SymLeft := TList<TASExprNode>.Create;
  try
    SymRight := TList<TASExprNode>.Create;
    try

      FindSymbols(Children[1], 'left', SymLeft);
      FindSymbols(Children[1], 'right', SymRight);

      Value.Sort(TComparer<TAlgosimObject>.Construct(
        function(const Left, Right: TAlgosimObject): Integer
        var
          res: TAlgosimObject;
          cmpres: TASR;
        begin
          PopulateSymbols(SymLeft, Left.Clone);
          PopulateSymbols(SymRight, Right.Clone);
          Children[1].Evaluate;
          res := Children[1].Value;
          CheckFailure(res);
          if res is TAlgosimInteger then
            Result := Sign(TAlgosimInteger(res).Value)
          else if (res is TAlgosimNumber) and res.TryToASR(cmpres) then
            Result := Sign(cmpres)
          else
            raise EAlgosimObjectException.CreateFmt(SComparerDidntReturnReal, [res.TypeName]);
        end
        ));

    finally
      SymRight.Free;
    end;
  finally
    SymLeft.Free;
  end;

end;

{ FCN_Shuffle }

procedure FCN_Shuffle.SimpleFunction;
begin
  Args.MoveObject<TAlgosimObject>(Value).Close;
  Result.Shuffle;
end;

{ FCN_Reverse }

procedure FCN_Reverse.SimpleFunction;
begin
  Args.MoveObject<TAlgosimObject>(Value).Close;
  Result.Reverse;
end;

{ FCN_Unique }

procedure FCN_Unique.SimpleFunction;
var
  Obj: TAlgosimObject;
  Eps: TASR;
begin
  CheckNumArgs([1, 2]);
  case Args.Count of
    1:
      begin
        Args.Extract(Obj).Close;
        Result := Obj.RemoveDuplicates;
      end;
    2:
      begin
        Args.Extract(Obj).ExtractNonNeg(Eps).Close;
        Result := Obj.RemoveDuplicatesEps(Eps);
      end;
  else
    ErrInvalidArguments;
  end;
end;

{ FCN_AdjUnique }

procedure FCN_AdjUnique.SimpleFunction;
var
  Obj: TAlgosimObject;
  Eps: TASR;
begin
  CheckNumArgs([1, 2]);
  case Args.Count of
    1:
      begin
        Args.Extract(Obj).Close;
        Result := Obj.RemoveAdjacentDuplicates;
      end;
    2:
      begin
        Args.Extract(Obj).ExtractNonNeg(Eps).Close;
        Result := Obj.RemoveAdjacentDuplicatesEps(Eps);
      end;
  else
    ErrInvalidArguments;
  end;
end;

{ FCN_Frequencies }

procedure FCN_Frequencies.SimpleFunction;
var
  Obj: TAlgosimObject;
  Eps: TASR;
begin
  CheckNumArgs([1, 2]);
  case Args.Count of
    1:
      begin
        Args.Extract(Obj).Close;
        Result := Obj.Frequencies;
      end;
    2:
      begin
        Args.Extract(Obj).ExtractNonNeg(Eps).Close;
        Result := Obj.FrequenciesEps(Eps);
      end;
  else
    ErrInvalidArguments;
  end;
end;

{ FCN_CollapseSequences }

procedure FCN_CollapseSequences.SimpleFunction;
var
  Obj: TAlgosimObject;
  Eps: TASR;
begin
  CheckNumArgs([1, 2]);
  case Args.Count of
    1:
      begin
        Args.Extract(Obj).Close;
        Result := Obj.CollapseSequences;
      end;
    2:
      begin
        Args.Extract(Obj).ExtractNonNeg(Eps).Close;
        Result := Obj.CollapseSequencesEps(Eps);
      end;
  else
    ErrInvalidArguments;
  end;
end;

{ FCN_ZeroVector }

procedure FCN_ZeroVector.SimpleFunction;
var
  Dim: Integer;
begin
  Args.ExtractPos(Dim).Close;
  Result := ASO(ZeroVector(Dim));
end;

{ FCN_ComplexZeroVector }

procedure FCN_ComplexZeroVector.SimpleFunction;
var
  Dim: Integer;
begin
  Args.ExtractPos(Dim).Close;
  Result := ASO(ComplexZeroVector(Dim));
end;

{ FCN_RandomVector }

procedure FCN_RandomVector.SimpleFunction;
var
  Dim: Integer;
begin
  Args.ExtractPos(Dim).Close;
  Result := ASO(RandomVector(Dim));
end;

{ FCN_RandomIntVector }

procedure FCN_RandomIntVector.SimpleFunction;
var
  Dim, A, B: Integer;
begin
  Args.ExtractPos(Dim).Extract(A).Extract(B).Close;
  if A >= B then
    raise EInvArgs.Create('The set of possible values is empty.');
  Result := ASO(RandomIntVector(Dim, A, B));
end;

{ FCN_RandomSignedVector }

procedure FCN_RandomSignedVector.SimpleFunction;
var
  Dim: Integer;
begin
  Args.ExtractPos(Dim).Close;
  Result := ASO(RandomVectorWithSigns(Dim));
end;

{ FCN_BasisVector }

procedure FCN_BasisVector.SimpleFunction;
var
  Dim, Index: Integer;
begin
  Args.ExtractPos(Dim).ExtractPos(Index).Close;
  Result := ASO(UnitVector(Dim, Index - 1));
end;

{ FCN_SequenceVector }

procedure FCN_SequenceVector.SimpleFunction;
var
  Start, &End, Step: Integer;
  A: TArray<TASI>;
begin

  if Args.Count = 1 then
  begin
    Start := 1;
    Args.ExtractPos(&End).Close;
    A := CreateIntSequence64(Start, &End);
  end
  else
  begin
    Args.Extract(Start).Extract(&End).ExtractPos(Step, 1).Close;
    A := CreateIntSequence64(Start, &End, Step);
  end;

  Result := ASO(TRealVector.Create(Int64ArrToRealArr(A)));

end;

{ FCN_SequenceList }

procedure FCN_SequenceList.SimpleFunction;
var
  Start, &End, Step: Integer;
  A: TArray<TASI>;
begin

  if Args.Count = 1 then
  begin
    Start := 1;
    Args.ExtractPos(&End).Close;
    A := CreateIntSequence64(Start, &End);
  end
  else
  begin
    Args.Extract(Start).Extract(&End).ExtractPos(Step, 1).Close;
    A := CreateIntSequence64(Start, &End, Step);
  end;

  Result := TAlgosimArray.CreateWithValue(A);

end;

{ TIntervalFunction }

procedure TIntervalFunction.SimpleFunction;
var
  a, b, b′, δ, t: TASR;
  L: TList<TASR>;
begin

  Args.Extract(a).Extract(b).ExtractPos(δ, 0).Close;

  if (a > b) or (a = b) and Openinterval then
  begin
    Result := TAlgosimArray.Create;
    Exit;
  end;

  if a = b then
  begin
    Result := TAlgosimArray.CreateWithValue([a]);
    Exit;
  end;

  if δ = 0 then
    δ := (b - a) / 1000;

  if OpenInterval then
  begin
    a := a + δ;
    b := b - δ;
  end;

  L := TList<TASR>.Create;
  try
    L.Capacity := Trunc((b - a) / δ) + 1;
    t := a;
    b′ := b + δ / 1000;    
    while t <= b′ do
    begin    
      L.Add(t);
      t := t + δ;
    end;
    if (L.Count > 0) and (L.Last > b) then
      L[L.Count - 1] := b;
    Result := TAlgosimArray.CreateWithValue(L.ToArray);
  finally
    L.Free;
  end;
  
end;

{ FCN_ClosedInterval }

procedure FCN_ClosedInterval.InitNode;
begin
  inherited;
  OpenInterval := False;
end;


{ FCN_OpenInterval }

procedure FCN_OpenInterval.InitNode;
begin
  inherited;
  OpenInterval := True;
end;

{ FCN_Random }

function FCN_Random.BuildLValue(LValueData: TLValueData): Boolean;
begin
  Result := ChildCount = 1;
  if Result then
  begin
    LValueData.Add(TLValuePathItem.Create(skRandom));
    Result := Children[0].BuildLValue(LValueData);
  end;
end;

procedure FCN_Random.DoExecute;
var
  Obj: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Obj) then Exit;
  Result := Obj.Random;
end;

function FCN_Random.LValuePart: Boolean;
begin
  Result := True;
end;

{ FCN_RandomInt }

procedure FCN_RandomInt.SimpleFunction;
var
  A, B: Integer;
begin

  if Args.Count = 1 then
  begin
    Args.ExtractPos(A).Close;
    Result := ASOInt(System.Random(A));
  end
  else
  begin
    Args.Extract(A).Extract(B).Close;
    if A >= B then
      raise EInvArgs.Create('The set of possible values is empty.');
    Result := ASOInt(RandomRange(A, B));
  end;

end;

{ FCN_RandomReal }

procedure FCN_RandomReal.SimpleFunction;
var
  A, B: TASR;
begin

  if Args.Count = 0 then
    Result := ASO(System.Random)
  else if Args.Count = 1 then
  begin
    Args.Extract(A).Close;
    Result := ASO(A * System.Random);
  end
  else
  begin
    Args.Extract(A).Extract(B).Close;
    Result := ASO(A + (B - A) * System.Random);
  end;

end;

{ FCN_SetRandomSeed }

procedure FCN_SetRandomSeed.SimpleFunction;
var
  Arg: Integer;
begin
  Args.Extract(Arg).Close;
  RandSeed := Arg;
  Result := ASO(success);
end;

{ FCN_Randomize }

procedure FCN_Randomize.SimpleFunction;
begin
  Args.Close;
  Randomize;
  Result := ASO(success);
end;

{ TASContainerFunction }

function __max_int(const A, B: TASI): TASI;
begin
  if A > B then
    Result := A
  else
    Result := B;
end;

function __min_int(const A, B: TASI): TASI;
begin
  if A < B then
    Result := A
  else
    Result := B;
end;

function __max_float(const A, B: TASR): TASR;
begin
  if A > B then
    Result := A
  else
    Result := B;
end;

function __min_float(const A, B: TASR): TASR;
begin
  if A < B then
    Result := A
  else
    Result := B;
end;

procedure TASContainerFunction.DoExecute;
const
  ARG_INDEX_EXPRESSION = 0;
  ARG_INDEX_SYMBOL = 1;
  ARG_INDEX_LOWER_BOUND = 2;
  ARG_INDEX_UPPER_BOUND = 3;
var
  i: Integer;
  k, m, n: TASI;
  Obj: TAlgosimObject;
  symbol: string;
  symbols: TList<TASExprNode>;
  list: TAlgosimArray;
  x, y: TASR;
  ifcn: function(const A, B: TASI): TASI;
  rfcn: function(const A, B: TASR): TASR;
begin

  CheckNumArgs([1, 2, 4]);

  if Args.Count = 1 then
  begin
    if not ExtractRef(0, Obj) then Exit;
    fcn(Obj);
  end

  else if (Args.Count = 2) and ((Self is FCN_Min) or (Self is FCN_Max)) then // special case: allow min(x, y) and max(x, y)
  begin

    if not EvalChildren then Exit;

    if Self is FCN_Min then
    begin
      ifcn := __min_int;
      rfcn := __min_float;
    end
    else if Self is FCN_Max then
    begin
      ifcn := __max_int;
      rfcn := __max_float;
    end
    else
      ErrInternal;

    if (Args.PeekAt(0) is TAlgosimInteger) and (Args.PeekAt(1) is TAlgosimInteger) then
    begin
      Args.Extract(m).Extract(n).Close;
      Result := ASOInt(ifcn(m, n));
    end
    else
    begin
      Args.Extract(x).Extract(y).Close;
      Result := ASO(rfcn(x, y));
    end;

  end

  else if Args.Count = 4 then
  begin

    for i := ARG_INDEX_LOWER_BOUND to ARG_INDEX_UPPER_BOUND do
      if not EvalChild(i) then Exit;

    Args.Skip.Skip.Extract(m).Extract(n).Close;

    CheckSymbol(ARG_INDEX_SYMBOL);
    symbol := TASSymbolExprNode(Children[ARG_INDEX_SYMBOL]).Symbol;

    symbols := TList<TASExprNode>.Create;
    try
      FindSymbols(Self.Children[ARG_INDEX_EXPRESSION], symbol, symbols);
      list := TAlgosimArray.Create;
      try
        if n - m + 1 > Integer.MaxValue then
          raise Exception.Create('Too many values for the index variable.');
        list.Capacity := Max(0, n - m + 1);
        for k := m to n do
        begin
          PopulateSymbols(symbols, ASOInt(k));
          Children[ARG_INDEX_EXPRESSION].Evaluate;
          if IsControl(Children[ARG_INDEX_EXPRESSION].Value) then
          begin
            TMover<TAlgosimObject>.Move(Value, Children[ARG_INDEX_EXPRESSION].Value);
            Exit;
          end;
          list.Add(Children[ARG_INDEX_EXPRESSION].Value.Clone);
        end;
        fcn(list);
      finally
        list.Free;
      end;
    finally
      symbols.Free;
    end;

  end

  else
    ErrInvalidArguments;

end;

{ FCN_Sum }

procedure FCN_Sum.fcn(AObject: TAlgosimObject);
begin
  Result := AObject.N_sum;
end;

{ FCN_Product }

procedure FCN_Product.fcn(AObject: TAlgosimObject);
begin
  Result := AObject.N_product;
end;

{ FCN_Min }

procedure FCN_Min.fcn(AObject: TAlgosimObject);
begin
  Result := AObject.N_min;
end;

{ FCN_Max }

procedure FCN_Max.fcn(AObject: TAlgosimObject);
begin
  Result := AObject.N_max;
end;

{ FCN_ArithmeticMean }

procedure FCN_ArithmeticMean.fcn(AObject: TAlgosimObject);
begin
  Result := AObject.N_ArithmeticMean;
end;

{ FCN_GeometricMean }

procedure FCN_GeometricMean.fcn(AObject: TAlgosimObject);
begin
  Result := AObject.N_GeometricMean;
end;

{ FCN_HarmonicMean }

procedure FCN_HarmonicMean.fcn(AObject: TAlgosimObject);
begin
  Result := AObject.N_HarmonicMean;
end;

{ TASContainerPredicateFunction }

procedure TASContainerPredicateFunction.DoExecute;
var
  Obj: TAlgosimObject;
  Predicate: TAlgosimFunctionObject;
begin
  CheckNumArgs(2);
  if not ExtractRef(0, Obj) then Exit;
  if not EvalChild(1) then Exit;
  Args(1).Extract(Predicate);
  fcn(Obj,
    function(AObject: TAlgosimObject): Boolean
    var
      res: TAlgosimObject;
    begin
      res := Predicate.Execute(Context, [AObject], False);
      try
        if res is TAlgosimBoolean then
          Result := TAlgosimBoolean(res).Value
        else
          raise EAlgosimObjectException.CreateFmt(SPredicateDidntReturnBool, [res.TypeName]);
      finally
        res.Free;
      end;
    end);
end;

{ FCN_Count }

procedure FCN_Count.DoExecute;
var
  Obj, Value: TAlgosimObject;
  Predicate: TAlgosimFunctionObject;
  Eps: TASR;
begin

  CheckNumArgs([2, 3]);
  if not ExtractRef(0, Obj) then Exit;
  if not EvalChildren(1) then Exit;

  if Args.PeekAt(1) is TAlgosimFunctionObject then
  begin
    Args.Skip.Extract(Predicate).Close;
    Result := ASOInt(Obj.Count(
      function(AObject: TAlgosimObject): Boolean
      var
        res: TAlgosimObject;
      begin
        res := Predicate.Execute(Context, [AObject], False);
        try
          if res is TAlgosimBoolean then
            Result := TAlgosimBoolean(res).Value
          else
            raise EAlgosimObjectException.CreateFmt(SPredicateDidntReturnBool, [res.TypeName]);
        finally
          res.Free;
        end;
      end
    ))
  end
  else
  begin
    case Args.Count of
      2:
        begin
          Args.Skip.Extract(Value).Close;
          Result := ASOInt(Obj.CountValue(Value));
        end;
      3:
        begin
          Args.Skip.Extract(Value).ExtractNonNeg(Eps).Close;
          Result := ASOInt(Obj.CountValueEps(Value, Eps));
        end;
    else
      ErrInvalidArguments;
    end;
  end;

end;

{ FCN_Contains }

procedure FCN_Contains.DoExecute;
var
  Obj, Value: TAlgosimObject;
  Eps: TASR;
begin
  CheckNumArgs([2, 3]);
  if not ExtractRef(0, Obj) then Exit;
  if not EvalChildren(1) then Exit;
  case Args.Count of
    2:
      begin
        Args.Skip.Extract(Value).Close;
        Result := ASO(Obj.Contains(Value));
      end;
    3:
      begin
        Args.Skip.Extract(Value).ExtractNonNeg(Eps).Close;
        Result := ASO(Obj.ContainsEps(Value, Eps));
      end;
  else
    ErrInvalidArguments;
  end;
end;

{ FCN_Exists }

procedure FCN_Exists.fcn(AObject: TAlgosimObject;
  APred: TASOPredicate);
begin
  Result := ASO(AObject.Exists(APred));
end;

{ FCN_ExistsUnique }

procedure FCN_ExistsUnique.fcn(AObject: TAlgosimObject;
  APred: TASOPredicate);
begin
  Result := ASO(AObject.ExistsUnique(APred));
end;

{ FCN_ForAll }

procedure FCN_ForAll.fcn(AObject: TAlgosimObject;
  APred: TASOPredicate);
begin
  Result := ASO(AObject.ForAll(APred));
end;

{ FCN_IndicesOf }

procedure FCN_IndicesOf.DoExecute;
var
  Obj, Value: TAlgosimObject;
  Predicate: TAlgosimFunctionObject;
  Eps: TASR;
begin

  CheckNumArgs([2, 3]);
  if not ExtractRef(0, Obj) then Exit;
  if not EvalChildren(1) then Exit;

  if Args.PeekAt(1) is TAlgosimFunctionObject then
  begin
    Args.Skip.Extract(Predicate).Close;
    Result := Obj.IndicesOf(
      function(AObject: TAlgosimObject): Boolean
      var
        res: TAlgosimObject;
      begin
        res := Predicate.Execute(Context, [AObject], False);
        try
          if res is TAlgosimBoolean then
            Result := TAlgosimBoolean(res).Value
          else
            raise EAlgosimObjectException.CreateFmt(SPredicateDidntReturnBool, [res.TypeName]);
        finally
          res.Free;
        end;
      end
    )
  end
  else
  begin
    case Args.Count of
      2:
        begin
          Args.Skip.Extract(Value).Close;
          Result := Obj.IndicesOfValue(Value);
        end;
      3:
        begin
          Args.Skip.Extract(Value).ExtractNonNeg(Eps).Close;
          Result := Obj.IndicesOfValueEps(Value, Eps);
        end;
    else
      ErrInvalidArguments;
    end;
  end;

end;

{ FCN_Filter }

procedure FCN_Filter.fcn(AObject: TAlgosimObject;
  APred: TASOPredicate);
begin
  Result := AObject.Filter(APred);
end;

{ FCN_Pick }

procedure FCN_Pick.DoExecute;
var
  Obj: TAlgosimObject;
  Predicate: TAlgosimFunctionObject;
  Level: Integer;
begin
  CheckNumArgs([2, 3]);
  if not ExtractRef(0, Obj) then Exit;
  if not EvalChildren(1) then Exit;
  Args
    .Skip
    .Extract(Predicate)
    .ExtractPos(Level, 1)
    .Close;
  Value := Obj.Pick(
    function(AObject: TAlgosimObject): Boolean
    var
      res: TAlgosimObject;
    begin
      res := Predicate.Execute(Context, [AObject], False);
      try
        if res is TAlgosimBoolean then
          Result := TAlgosimBoolean(res).Value
        else
          raise EAlgosimObjectException.CreateFmt(SPredicateDidntReturnBool, [res.TypeName]);
      finally
        res.Free;
      end;
    end,
    Level);
end;

{ FCN_PickRecursive }

procedure FCN_PickRecursive.fcn(AObject: TAlgosimObject;
  APred: TASOPredicate);
begin
  Result := AObject.PickRecursive(APred);
end;

{ FCN_Apply }

procedure FCN_Apply.SimpleFunction;
var
  Fcn: TAlgosimFunctionObject;
  Level: Integer;
  &Set: TAlgosimSet;
  i: Integer;
begin

  if Args.PeekAt(0) is TAlgosimSet then
  begin
    // sets don't support the Apply method (cannot simply replace
    // elements in-place: that might create a set with duplicate elements)
    Args.Extract(&Set).Extract(Fcn).Close; // for sets, we don't support the Level argument for simplicity (again, by altering the set's elements, the parent set might end up with duplicate elements)
    Result := TAlgosimSet.Create;
    Result.Capacity := &Set.Capacity;
    for i := 1 to &Set.ElementCount do
      Result.AddElement(Fcn.Execute(Context, [&Set.Elements[i]], False));
    Exit;
  end;

  Args.MoveObject(Value).Extract(Fcn).ExtractPos(Level, 1).Close;
  Value.Apply(
    function(AObject: TAlgosimObject): TAlgosimObject
    begin
      Result := Fcn.Execute(Context, [AObject], False);
    end,
    nil,
    Level
  );

end;

{ FCN_ApplyIf }

procedure FCN_ApplyIf.SimpleFunction;
var
  Pred, Fcn: TAlgosimFunctionObject;
  Level: Integer;
begin
  Args.MoveObject(Value).Extract(Pred).Extract(Fcn).ExtractPos(Level, 1).Close;
  Value.Apply(
    function(AObject: TAlgosimObject): TAlgosimObject
    begin
      Result := Fcn.Execute(Context, [AObject], False);
    end,
    function(AObject: TAlgosimObject): Boolean
    var
      res: TAlgosimObject;
    begin
      res := Pred.Execute(Context, [AObject], False);
      try
        if res is TAlgosimBoolean then
          Result := TAlgosimBoolean(res).Value
        else
          raise EAlgosimObjectException.CreateFmt(SPredicateDidntReturnBool, [res.TypeName]);
      finally
        res.Free;
      end;
    end,
    Level
  );
end;

{ FCN_ReplaceAll }

procedure FCN_ReplaceAll.SimpleFunction;
var
  OldVal, NewVal: TAlgosimObject;
  Level: Integer;
begin
  Args
    .MoveObject(Value)
    .Extract(OldVal)
    .Extract(NewVal)
    .ExtractPos(Level, 1)
    .Close;
  Value.Replace(OldVal, NewVal, Level);
end;

{ FCN_ReplaceIf }

procedure FCN_ReplaceIf.SimpleFunction;
var
  NewVal: TAlgosimObject;
  Pred: TAlgosimFunctionObject;
  Level: Integer;
begin
  Args
    .MoveObject(Value)
    .Extract(Pred)
    .Extract(NewVal)
    .ExtractPos(Level, 1)
    .Close;
  Value.Replace(
    function(AObject: TAlgosimObject): Boolean
    var
      res: TAlgosimObject;
    begin
      res := Pred.Execute(Context, [AObject], False);
      try
        if res is TAlgosimBoolean then
          Result := TAlgosimBoolean(res).Value
        else
          raise EAlgosimObjectException.CreateFmt(SPredicateDidntReturnBool, [res.TypeName]);
      finally
        res.Free;
      end;
    end,
    NewVal,
    Level);
end;

{ FCN_ReplaceEvery }

procedure FCN_ReplaceEvery.SimpleFunction;
var
  NewVal: TAlgosimObject;
  Level: Integer;
begin
  Args
    .MoveObject(Value)
    .Extract(NewVal)
    .ExtractPos(Level, 1)
    .Close;
  Value.Replace(NewVal, Level);
end;

{ FCN_RemoveAll }

procedure FCN_RemoveAll.SimpleFunction;
var
  OldVal: TAlgosimObject;
  Level: Integer;
begin
  Args
    .MoveObject(Value)
    .Extract(OldVal)
    .ExtractPos(Level, 1)
    .Close;
  Value.RemoveAll(OldVal, Level);
end;

{ FCN_RemoveIf }

procedure FCN_RemoveIf.SimpleFunction;
var
  Pred: TAlgosimFunctionObject;
  Level: Integer;
  &Set: TAlgosimSet;
  i: Integer;
  res: TAlgosimObject;
begin

  if Args.PeekAt(0) is TAlgosimSet then
  begin

    // sets don't support the Remove method

    Args.Extract(&Set).Extract(Pred).Close;
    Result := TAlgosimSet.Create;
    Result.Capacity := &Set.Capacity;

    for i := 1 to &Set.ElementCount do
    begin

      res := Pred.Execute(Context, [&Set.Elements[i]], False);
      try
        if res is TAlgosimBoolean then
        begin
          if not res.ToBoolean then
            Result.AddElement(&Set.Elements[i].Clone);
        end
        else
          raise EAlgosimObjectException.CreateFmt(SPredicateDidntReturnBool, [res.TypeName]);
      finally
        res.Free;
      end;

    end;

    Exit;

  end;

  Args
    .MoveObject(Value)
    .Extract(Pred)
    .ExtractPos(Level, 1)
    .Close;
  Value.RemoveIf(
    function(AObject: TAlgosimObject): Boolean
    var
      res: TAlgosimObject;
    begin
      res := Pred.Execute(Context, [AObject], False);
      try
        if res is TAlgosimBoolean then
          Result := TAlgosimBoolean(res).Value
        else
          raise EAlgosimObjectException.CreateFmt(SPredicateDidntReturnBool, [res.TypeName]);
      finally
        res.Free;
      end;
    end,
    Level);

end;

{ FCN_RealNumber }

procedure FCN_RealNumber.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := ASO(Arg.ToRealNumber);
end;

{ FCN_ComplexNumber }

procedure FCN_ComplexNumber.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := ASO(Arg.ToComplexNumber);
end;

{ FCN_Number }

procedure FCN_Number.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := Arg.ToNumber;
end;

{ FCN_Integer }

procedure FCN_Integer.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := ASOInt(Arg.ToASI);
end;

{ FCN_String }

procedure FCN_String.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := ASO(Arg.ToString);
end;

{ FCN_RealVector }

procedure FCN_RealVector.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := ASO(Arg.AsRealVector);
end;

{ FCN_ComplexVector }

procedure FCN_ComplexVector.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := ASO(Arg.AsComplexVector);
end;

{ FCN_Vector }

procedure FCN_Vector.SimpleFunction;
var
  Arg: TAlgosimObject;
begin

  // Create a matrix
  if Args.PeekAt(0) is TAlgosimVector then
  begin

    if HasComplexArg then
      Result := ASO(TComplexMatrix.CreateFromRows(Args.ExtractComplexVectors))
    else
      Result := ASO(TRealMatrix.CreateFromRows(Args.ExtractRealVectors));

    Exit;

  end;

  // Create a vector
  case ChildCount of
    0:
      raise EAlgosimObjectException.Create(SVectDim);
    1:
      begin
        Args.Extract(Arg).Close;
        Result := Arg.AsVector;
      end;
  else
    if HasComplexArg then
      Result := ASO(TComplexVector.Create(Args.ExtractComplexNumbers))
    else
      Result := ASO(TRealVector.Create(Args.ExtractRealNumbers))
  end;

end;

{ FCN_RealMatrix }

procedure FCN_RealMatrix.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := ASO(Arg.AsRealMatrix);
end;

{ FCN_ComplexMatrix }

procedure FCN_ComplexMatrix.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := ASO(Arg.AsComplexMatrix);
end;

{ FCN_Matrix }

procedure FCN_Matrix.SimpleFunction;
var
  Arg: TAlgosimObject;
  ColCount: Integer;
  rnums: TArray<TASR>;
  cnums: TArray<TASC>;
begin

  case Args.Count of
    0:
      raise EAlgosimObjectException.Create(SMatDim);
    1:
      begin
        Args.Extract(Arg).Close;
        Result := Arg.AsMatrix;
      end;
  else

    if HasComplexArg then
    begin
      cnums := Args.ExtractPos(ColCount).ExtractComplexNumbers;
      Result := ASO(TComplexMatrix.Create(cnums, ColCount));
    end
    else
    begin
      rnums := Args.ExtractPos(ColCount).ExtractRealNumbers;
      Result := ASO(TRealMatrix.Create(rnums, ColCount));
    end;

  end;

end;

{ FCN_Boolean }

procedure FCN_Boolean.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := ASO(Arg.ToBoolean);
end;

{ FCN_ToList }

procedure FCN_ToList.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := Arg.ToList;
end;

{ FCN_ToSet }

procedure FCN_ToSet.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := Arg.ToSet;
end;

{ FCN_ToTable }

procedure FCN_ToTable.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := ASO(Arg.ToTable);
end;

{ FCN_BinaryData }

procedure FCN_BinaryData.SimpleFunction;
var
  Arg: TAlgosimObject;
begin
  Args.Extract(Arg).Close;
  Result := Arg.ToBinaryObject;
end;

{ FCN_MatrixFromCols }

procedure FCN_MatrixFromCols.SimpleFunction;
begin

  if HasComplexArg then
    Result := ASO(TComplexMatrix.CreateFromColumns(Args.ExtractComplexVectors))
  else
    Result := ASO(TRealMatrix.CreateFromColumns(Args.ExtractRealVectors));

end;

{ FCN_MatrixFromRows }

procedure FCN_MatrixFromRows.SimpleFunction;
begin

  if HasComplexArg then
    Result := ASO(TComplexMatrix.CreateFromRows(Args.ExtractComplexVectors))
  else
    Result := ASO(TRealMatrix.CreateFromRows(Args.ExtractRealVectors));

end;

{ FCN_MatrixFromBlocks }

procedure FCN_MatrixFromBlocks.SimpleFunction;
var
  ColCount: Integer;
begin

  Args.ExtractPos(ColCount);

  if HasComplexArg then
    Result := ASO(TComplexMatrix.Create(Args.Skip.ExtractComplexMatrices, ColCount))
  else
    Result := ASO(TRealMatrix.Create(Args.Skip.ExtractRealMatrices, ColCount));

end;

{ FCN_List }

procedure FCN_List.SimpleFunction;
var
  i: Integer;
  tmpobj: TAlgosimObject;
begin

  Result := TAlgosimArray.Create;
  Result.Capacity := ChildCount;
  for i := 0 to ChildCount - 1 do
  begin
    TMover<TAlgosimObject>.Move(tmpobj, Children[i].Value);
    Result.AddElement(tmpobj);
  end;

end;

{ FCN_Set }

procedure FCN_Set.SimpleFunction;
var
  i: Integer;
  tmpobj: TAlgosimObject;
begin

  Result := TAlgosimSet.Create;
  Result.Capacity := ChildCount;
  for i := 0 to ChildCount - 1 do
  begin
    TMover<TAlgosimObject>.Move(tmpobj, Children[i].Value); {noexcept}
    Result.AddElement(tmpobj);
  end;

end;

{ FCN_Union }

procedure FCN_Union.SimpleFunction;
var
  U, V: TAlgosimSet;
begin
  Args.Extract(U).Extract(V).Close;
  Result := TAlgosimSet.Union(U, V);
end;

{ FCN_Intersection }

procedure FCN_Intersection.SimpleFunction;
var
  U, V: TAlgosimSet;
begin
  Args.Extract(U).Extract(V).Close;
  Result := TAlgosimSet.Intersection(U, V);
end;

{ FCN_SetDifference }

procedure FCN_SetDifference.SimpleFunction;
var
  U, V: TAlgosimSet;
begin
  Args.Extract(U).Extract(V).Close;
  Result := TAlgosimSet.Difference(U, V);
end;

{ FCN_SymDiff }

procedure FCN_SymDiff.SimpleFunction;
var
  U, V: TAlgosimSet;
begin
  Args.Extract(U).Extract(V).Close;
  Result := TAlgosimSet.SymmetricDifference(U, V);
end;

{ FCN_Complement }

procedure FCN_Complement.SimpleFunction;
var
  Universe: TAlgosimObject;
  U: TAlgosimSet;
begin
  Args.Extract(U).Close;
  Context.GetObjRef('universe', Universe);
  if not (Universe is TAlgosimSet) then
    raise EAlgosimObjectException.CreateFmt(SUniverseNotASet, [Universe.ClassTypeName]);
  Result := TAlgosimSet.Difference(TAlgosimSet(Universe), U);
end;

{ FCN_ElementOf }

procedure FCN_ElementOf.SimpleFunction;
var
  x: TAlgosimObject;
  U: TAlgosimSet;
begin
  Args.Extract(x).Extract(U).Close;
  Result := ASO(TAlgosimSet.ElementOf(x, U));
end;

{ FCN_NotElementOf }

procedure FCN_NotElementOf.SimpleFunction;
var
  x: TAlgosimObject;
  U: TAlgosimSet;
begin
  Args.Extract(x).Extract(U).Close;
  Result := ASO(not TAlgosimSet.ElementOf(x, U));
end;

{ FCN_ContainsAsElement }

procedure FCN_ContainsAsElement.SimpleFunction;
var
  x: TAlgosimObject;
  U: TAlgosimSet;
begin
  Args.Extract(U).Extract(x).Close;
  Result := ASO(TAlgosimSet.ElementOf(x, U));
end;

{ FCN_NotContainsAsElement }

procedure FCN_NotContainsAsElement.SimpleFunction;
var
  x: TAlgosimObject;
  U: TAlgosimSet;
begin
  Args.Extract(U).Extract(x).Close;
  Result := ASO(not TAlgosimSet.ElementOf(x, U));
end;

{ FCN_Subset }

procedure FCN_Subset.SimpleFunction;
var
  U, V: TAlgosimSet;
begin
  Args.Extract(U).Extract(V).Close;
  Result := ASO(TAlgosimSet.Subset(U, V));
end;

{ FCN_ProperSubset }

procedure FCN_ProperSubset.SimpleFunction;
var
  U, V: TAlgosimSet;
begin
  Args.Extract(U).Extract(V).Close;
  Result := ASO(TAlgosimSet.ProperSubset(U, V));
end;

{ FCN_Superset }

procedure FCN_Superset.SimpleFunction;
var
  U, V: TAlgosimSet;
begin
  Args.Extract(U).Extract(V).Close;
  Result := ASO(TAlgosimSet.Subset(V, U));
end;

{ FCN_ProperSuperset }

procedure FCN_ProperSuperset.SimpleFunction;
var
  U, V: TAlgosimSet;
begin
  Args.Extract(U).Extract(V).Close;
  Result := ASO(TAlgosimSet.ProperSubset(V, U));
end;

{ FCN_TypeName }

procedure FCN_TypeName.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASO(Arg.TypeName);
end;

{ FCN_ClassTypeData }

procedure FCN_ClassTypeData.DoExecute;

{$IF SizeOf(TAlgosimObjectClassFlags) = 1}
type TClassFlagInt = UInt8;
{$ELSEIF SizeOf(TAlgosimObjectClassFlags) = 2}
type TClassFlagInt = UInt16;
{$ELSEIF SizeOf(TAlgosimObjectClassFlags) = 4}
type TClassFlagInt = UInt32;
{$ENDIF}

var
  Arg: TAlgosimObject;
begin

  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;

  with Arg.ClassData do
    Result := ASO(
      [
        sm('name', ASO(ClassTypeName)),
        sm('ClassFlags',
          ASOInt(
              {$IF Declared(TClassFlagInt)}
                TClassFlagInt(ClassFlags)
              {$ELSE}
                -1
              {$ENDIF}
            )
          ),
        sm('IsObjectContainer', ASO(asoObjectContainer in ClassFlags)),
        sm('IsValueContainer', ASO(asoValueContainer in ClassFlags)),
        sm('IsPlanarContainer', ASO(asoPlanarContainer in ClassFlags)),
        sm('IsOrderedContainer', ASO(asoOrderedContainer in ClassFlags)),
        sm('IsComplexType', ASO(asoComplex in ClassFlags))
      ]
    );

end;

{ FCN_ClassTypeName }

procedure FCN_ClassTypeName.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASO(Arg.ClassTypeName);
end;

{ FCN_HasComplexType }

procedure FCN_HasComplexType.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASO(Arg.IsComplex);
end;

{ FCN_IsObjectContainer }

procedure FCN_IsObjectContainer.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASO(Arg.IsObjectContainer);
end;

{ FCN_IsValueContainer }

procedure FCN_IsValueContainer.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASO(Arg.IsValueContainer);
end;

{ FCN_IsPlanarContainer }

procedure FCN_IsPlanarContainer.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASO(Arg.IsPlanarContainer);
end;

{ FCN_IsOrderedContainer }

procedure FCN_IsOrderedContainer.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASO(Arg.IsOrderedContainer);
end;

{ FCN_Beep }

procedure FCN_Beep.SimpleFunction;
resourcestring
  SWin32MessageBeep = 'Couldn''t produce message beep using the native OS API.';
  SWin32Beep = 'Couldn''t produce sinusoidal beep using the native OS API.';
  SBeepSoundType = 'Unsupported beep sound type: "%s"';
  SToneFrequency = 'Unsupported tone frequency: %d Hz';
  SToneDuration = 'Too long tone duration: %d ms';
var
  s: string;
  MB_const: Integer;
  res: Boolean;
  freq, dur: Integer;
begin

  CheckNumArgs([0, 1, 2]);

  case ChildCount of
    0..1:
      begin

        Args.Extract(s, 'default').Close;

        if SameText(s, 'default') then
          MB_const := MB_OK
        else if SameText(s, 'information') then
          MB_const := MB_ICONINFORMATION
        else if SameText(s, 'warning') then
          MB_const := MB_ICONWARNING
        else if SameText(s, 'error') then
          MB_const := MB_ICONERROR
        else if SameText(s, 'question') then
          MB_const := MB_ICONQUESTION
        else
          raise EInvArgs.CreateFmt(SBeepSoundType, [s]);

        res := Windows.MessageBeep(MB_const);

        if not res then
          raise EAlgosimOSError.Create(SWin32MessageBeep);

      end;

    2:
      begin

        Args.ExtractPos(freq).ExtractNonNeg(dur).Close;

        if not InRange(freq, 37, 32767) then
          raise EInvArgs.CreateFmt(SToneFrequency, [freq]);

        if dur > 30000 then
          raise EInvArgs.CreateFmt(SToneDuration, [dur]);

        res := Windows.Beep(freq, dur);

        if not res then
          raise EAlgosimOSError.Create(SWin32Beep);

      end;
  else
    ErrInvalidArguments;
  end;

  Result := ASO(null);

end;

{ FCN_Wait }

procedure FCN_Wait.SimpleFunction;
var
  Dur: TASR;
  C0, C1: UInt64;
  DurMS: Cardinal;
  SignaledObj: THandleObject;
begin

  Args.ExtractNonNeg(Dur).Close;

  if Round(1000*Dur) > DurMS.MaxValue then
    raise Exception.Create('Too large timeout.');

  DurMS := Round(1000*Dur);

  if TThread.Current.ThreadID = MainThreadID then
  begin
    Sleep(DurMS);
    Exit;
  end;

  while DurMS > 0 do
  begin
    C0 := GetTickCount64;
    case
      TEvent.WaitForMultiple(
        [Context.AbortCurrentEvent, Context.EnterPauseEvent],
        DurMS,
        False,
        SignaledObj
      )
    of
      wrSignaled:
        begin
          if SignaledObj = Context.AbortCurrentEvent then
            ManualAbort
          else if SignaledObj = Context.EnterPauseEvent then
          begin
            C1 := GetTickCount64;
            if DoPause(Context.ResumeEvent, Context.AbortCurrentEvent) = raAbort then
              ManualAbort;
            if C1 - C0 >= DurMS then
            begin
              Result := ASO(null);
              Exit;
            end
            else
              Dec(DurMS, Cardinal(C1 - C0));
          end;
        end;
      wrTimeout:
        begin
          Result := ASO(null);
          Exit;
        end
    else
      raise Exception.Create('Wait failed.');
    end;
  end;

end;

{ FCN_GetTickCount }

procedure FCN_GetTickCount.SimpleFunction;
begin
  Args.Close;
  Result := ASOInt(GetTickCount64);
end;

{ FCN_Heaviside }

procedure FCN_Heaviside.InitNode;
begin
  rfcn := ASNum.Heaviside;
end;

{ FCN_Ramp }

procedure FCN_Ramp.InitNode;
begin
  rfcn := ASNum.Ramp;
end;

{ FCN_Rect }

procedure FCN_Rect.InitNode;
begin
  rfcn := ASNum.Rectfcn;
end;

{ FCN_Tri }

procedure FCN_Tri.InitNode;
begin
  rfcn := ASNum.Tri;
end;

{ FCN_GetProperty }

procedure FCN_GetProperty.SimpleFunction;
var
  Arg: string;
begin
  Args.Extract(Arg).Close;
  Result := Context.GetPropVal(Arg);
end;

{ FCN_Integrate }

procedure FCN_Integrate.DoExecute;
resourcestring
  SIntegrandRealValued = 'Integrand must be a real-valued function.';
const
  ARG_INDEX_EXPRESSION = 0;
  ARG_INDEX_SYMBOL = 1;
  ARG_INDEX_LOWER_LIMIT = 2;
  ARG_INDEX_UPPER_LIMIT = 3;
var
  symbol: string;
  symbols: TList<TASExprNode>;
  LowerBound, UpperBound: TASR;
  IntegrationParams: TIntegrationParams;
  Δx: TASR;
begin

  CheckNumArgs([4, 5]);
  CheckSymbol(ARG_INDEX_SYMBOL);
  symbol := TASSymbolExprNode(Children[ARG_INDEX_SYMBOL]).Symbol;

  if not EvalChildren(ARG_INDEX_LOWER_LIMIT) then
    Exit;

  Args.Skip.Skip.Extract(LowerBound).Extract(UpperBound).ExtractPos(Δx, 0).Close;

  symbols := TList<TASExprNode>.Create;
  try
    FindSymbols(Children[ARG_INDEX_EXPRESSION], symbol, symbols);

    if Δx > 0 then
      IntegrationParams := TIntegrationParams.Delta(Δx)
    else
      IntegrationParams := TIntegrationParams.N(100000);

    Value := ASO
      (
        ASNum.integrate(
          function(const X: TASR): TASR
          begin
            PopulateSymbols(symbols, ASO(X));
            Children[ARG_INDEX_EXPRESSION].Evaluate;
            CheckFailure(Children[ARG_INDEX_EXPRESSION].Value);
            if not Children[ARG_INDEX_EXPRESSION].Value.TryToASR(Result) then
              raise EAlgosimObjectException.Create(SIntegrandRealValued);
          end,
          LowerBound,
          UpperBound,
          IntegrationParams
        )
      );

  finally
    symbols.Free;
  end;

end;

{ FCN_Differentiate }

procedure FCN_Differentiate.DoExecute;
resourcestring
  SDiffFcnRealValued = 'Function to differentiate must be real-valued.';
const
  ARG_INDEX_EXPRESSION = 0;
  ARG_INDEX_SYMBOL = 1;
  ARG_INDEX_POINT = 2;
  ARG_INDEX_EPSILON = 3;
var
  symbol: string;
  symbols: TList<TASExprNode>;
  Point: TASR;
  Epsilon: TASR;
begin

  CheckNumArgs([3, 4]);
  CheckSymbol(ARG_INDEX_SYMBOL);
  symbol := TASSymbolExprNode(Children[ARG_INDEX_SYMBOL]).Symbol;

  if not EvalChildren(2) then Exit;
  Args.Skip.Skip.Extract(Point).ExtractNonNeg(Epsilon, 1E-6).Close;

  symbols := TList<TASExprNode>.Create;
  try
    FindSymbols(Children[ARG_INDEX_EXPRESSION], symbol, symbols);

    Self.Value := ASO
      (
        ASNum.differentiate(
          function(const X: TASR): TASR
          begin
            PopulateSymbols(symbols, ASO(X));
            Children[ARG_INDEX_EXPRESSION].Evaluate;
            CheckFailure(Children[ARG_INDEX_EXPRESSION].Value);
            if not Children[ARG_INDEX_EXPRESSION].Value.TryToASR(Result) then
              raise EAlgosimObjectException.Create(SDiffFcnRealValued);
          end,
          Point,
          Epsilon
        )
      )

  finally
    symbols.Free;
  end;

end;

{ FCN_Length }

procedure FCN_Length.DoExecute;
var
  Arg: TAlgosimObject;
begin
  CheckNumArgs(1);
  if not ExtractRef(0, Arg) then Exit;
  Result := ASOInt(Arg.ValueCount);
end;

{ FCN_Pos }

procedure FCN_Pos.SimpleFunction;
var
  Str, Substr: string;
  Flags: TSysCharSet;
  SearchOptions: TStringSearchOptions;
  Offset: Integer;
begin

  Args
    .Extract(Str)
    .Extract(Substr)
    .Extract(Flags, restr, ['i', 'w'], defval, [])
    .ExtractPos(Offset, 1)
    .Close;

  SearchOptions := [];
  if AnsiChar('i') in Flags then
    Include(SearchOptions, ssoIgnoreCase);
  if AnsiChar('w') in Flags then
    Include(SearchOptions, ssoWholeWords);

  Dec(Offset);

  Result := ASOInt(ASStrFcns.SubstringFirstIndex(Substr, Str, SearchOptions, Offset));

end;

{ FCN_StringContains }

procedure FCN_StringContains.SimpleFunction;
var
  Str, Substr: string;
  Flags: TSysCharSet;
  SearchOptions: TStringSearchOptions;
  Offset: Integer;
begin

  Args
    .Extract(Str)
    .Extract(Substr)
    .Extract(Flags, restr, ['i', 'w'], defval, [])
    .ExtractPos(Offset, 1)
    .Close;

  SearchOptions := [];
  if AnsiChar('i') in Flags then
    Include(SearchOptions, ssoIgnoreCase);
  if AnsiChar('w') in Flags then
    Include(SearchOptions, ssoWholeWords);

  Dec(Offset);

  Result := ASO(ASStrFcns.SubstringFirstIndex(Substr, Str, SearchOptions, Offset) <> 0);

end;

{ FCN_SubstringCount }

procedure FCN_SubstringCount.SimpleFunction;
var
  Str, Substr: string;
  Flags: TSysCharSet;
  SearchOptions: TStringSearchOptions;
  Offset: Integer;
begin

  Args
    .Extract(Str)
    .Extract(Substr)
    .Extract(Flags, restr, ['i', 'w'], defval, [])
    .ExtractPos(Offset, 1)
    .Close;

  SearchOptions := [];
  if AnsiChar('i') in Flags then
    Include(SearchOptions, ssoIgnoreCase);
  if AnsiChar('w') in Flags then
    Include(SearchOptions, ssoWholeWords);

  Dec(Offset);

  Result := ASOInt(ASStrFcns.SubstringCount(Substr, Str, SearchOptions, Offset));

end;

{ FCN_SubstringIndices }

procedure FCN_SubstringIndices.SimpleFunction;
var
  Str, Substr: string;
  Flags: TSysCharSet;
  SearchOptions: TStringSearchOptions;
  Offset: Integer;
  List: TList<Integer>;
begin

  Args
    .Extract(Str)
    .Extract(Substr)
    .Extract(Flags, restr, ['i', 'w'], defval, [])
    .ExtractPos(Offset, 1)
    .Close;

  SearchOptions := [];
  if AnsiChar('i') in Flags then
    Include(SearchOptions, ssoIgnoreCase);
  if AnsiChar('w') in Flags then
    Include(SearchOptions, ssoWholeWords);

  Dec(Offset);

  List := TList<Integer>.Create;
  try
    ASStrFcns.SubstringCount(Substr, Str, SearchOptions, Offset, List);
    Result := TAlgosimArray.CreateWithValue(List.ToArray);
  finally
    List.Free;
  end;

end;

{ FCN_StringReplace }

procedure FCN_StringReplace.SimpleFunction;
var
  Str, Substr, NewText: string;
  Flags: TSysCharSet;
  SearchOptions: TStringSearchOptions;
  Offset: Integer;
begin

  Args
    .Extract(Str)
    .Extract(Substr)
    .Extract(NewText)
    .Extract(Flags, restr, ['i', 'w'], defval, [])
    .ExtractPos(Offset, 1)
    .Close;

  SearchOptions := [];
  if AnsiChar('i') in Flags then
    Include(SearchOptions, ssoIgnoreCase);
  if AnsiChar('w') in Flags then
    Include(SearchOptions, ssoWholeWords);

  Dec(Offset);

  Result := ASO(ASStrFcns.StringReplace(Str, Substr, NewText, SearchOptions, Offset));

end;

{ FCN_Split }

procedure FCN_Split.SimpleFunction;
var
  Str, Sep: string;
  Seps: TArray<string>;
begin
  if Args.PeekAt(1) is TAlgosimString then
  begin
    Args.Extract(Str).Extract(Sep).Close;
    Result := TAlgosimArray.CreateWithValue(Str.Split([Sep]));
  end
  else
  begin
    Args.Extract(Str).Extract(Seps).Close;
    Result := TAlgosimArray.CreateWithValue(Str.Split(Seps));
  end;
end;

{ FCN_Join }

procedure FCN_Join.SimpleFunction;
var
  List, Elem: TAlgosimObject;
  Fcn: TAlgosimFunctionObject;
  Sep, Li, Ri, Lo, Ro: string;
  strs: TArray<string>;
  res: string;
  i, c, j: Integer;
begin

  Fcn := nil;

  if Args.PeekAt(1) is TAlgosimFunctionObject then
    Args
      .Extract(List)
      .Extract(Fcn)
      .Extract(Sep, ', ')
      .Extract(Li, '')
      .Extract(Ri, '')
      .Extract(Lo, '')
      .Extract(Ro, '')
      .Close
  else
    Args
      .Extract(List)
      .Extract(Sep, ', ')
      .Extract(Li, '')
      .Extract(Ri, '')
      .Extract(Lo, '')
      .Extract(Ro, '')
      .Close;

  if not List.IsObjectContainer then
    ErrInvalidArguments;

  SetLength(strs, List.ValueCount);
  c := 0;
  for i := 0 to High(strs) do
  begin
    if Assigned(Fcn) then
    begin
      Elem := Fcn.Execute(Context, [List.Elements[i + 1]], False);
      try
        strs[i] := Elem.ToString;
      finally
        Elem.Free;
      end;
    end
    else
      strs[i] := List.Elements[i + 1].ToString;
    Inc(c, strs[i].Length);
  end;

  SetLength(res,
    Lo.Length + Ro.Length +
    c +
    List.ElementCount * (Li.Length + Ri.Length) +
    Math.Max(0, List.ElementCount - 1) * Sep.Length);

  j := 1;

  if not Lo.IsEmpty then
  begin
    Move(Lo[1], res[j], Lo.Length * sizeof(char));
    Inc(j, Lo.Length);
  end;

  for