Path: /sdk/add_on/scriptmath/

This add-on registers the math functions from the standard C runtime library with the script engine. Use RegisterScriptMath(asIScriptEngine*) to perform the registration.

By defining the preprocessor word AS_USE_FLOAT=0, the functions will be registered to take and return doubles instead of floats.

The function RegisterScriptMathComplex(asIScriptEngine*) registers a type that represents a complex number, i.e. a number with real and imaginary parts.

Public script interface

  // Trigonometric functions
  float cos(float rad);
  float sin(float rad);
  float tan(float rad);

  // Inverse trigonometric functions
  float acos(float val);
  float asin(float val);
  float atan(float val);
  float atan2(float y, float x);

  // Hyperbolic functions
  float cosh(float rad);
  float sinh(float rad);
  float tanh(float rad);

  // Logarithmic functions
  float log(float val);
  float log10(float val);

  // Power to
  float pow(float val, float exp);

  // Square root
  float sqrt(float val);

  // Absolute value
  float abs(float val);

  // Ceil and floor functions
  float ceil(float val);
  float floor(float val);

  // Returns the fraction
  float fraction(float val);

  // Approximate float comparison, to deal with numeric imprecision
  bool closeTo(float a, float b, float epsilon = 0.00001f);
  bool closeTo(double a, double b, double epsilon = 0.0000000001);

  // Conversion between floating point and IEEE 754 representations
  float  fpFromIEEE(uint raw); 
  double fpFromIEEE(uint64 raw);
  uint   fpToIEEE(float fp);
  uint64 fpToIEEE(double fp);

Functions

cos, sin, tan

Calculates the trigonometric functions cosine, sine, and tangent. The input angle should be given in radian.

acos, asin, atan

Calculates the inverse of the trigonometric functions cosine, sine, and tangent. The returned angle is given in radian.

atan2

Calculates the inverse of the trigonometric function tangent. The input is the y and x proportions. The returned angle is given in radian.

cosh, sinh, tanh

Calculates the hyperbolic of the cosine, sine, and tangent. The input angle should be given in radian.

log, log10

Calculates the logarithm of the input value. log is the natural logarithm and log10 is the base-10 logarithm.

pow

Calculates the based raised to the power of exponent.

sqrt

Calculates the square root of the value.

abs

Returns the absolute value.

ceil, floor

ceil returns the closest integer number that is higher or equal to the input. Floor returns the closest integer number that is lower or equal to the input.

fraction

Returns the fraction of the number, i.e. what remains after taking away the integral number.

closeTo

Due to numerical errors with the binary representation of real numbers it is often difficult to do direct comparisons of two float values. The closeTo function will return true of the two values are almost equal, allowing for a small difference up to the size of the epsilon value.

fpFromIEEE, fpToIEEE

Translates the float to and from IEEE 754 representation. This can be used if one wishes to directly inspect or manipulate the floating point value in the binary representation.

The complex type

  // This type represents a complex number with real and imaginary parts
  class complex
  {
    // Constructors
    complex();
    complex(const complex &in);
    complex(float r);
    complex(float r, float i);

    // Equality operator
    bool opEquals(const complex &in) const;

    // Compound assignment operators
    complex &opAddAssign(const complex &in);
    complex &opSubAssign(const complex &in);
    complex &opMulAssign(const complex &in);
    complex &opDivAssign(const complex &in);

    // Math operators
    complex opAdd(const complex &in) const;
    complex opSub(const complex &in) const;
    complex opMul(const complex &in) const;
    complex opDiv(const complex &in) const;

    // Returns the absolute value (magnitude)
    float abs() const;

    // Swizzle operators
    complex get_ri() const;
    void set_ri(const complex &in);
    complex get_ir() const;
    void set_ir(const complex &in);

    // The real and imaginary parts
    float r;
    float i;
  }

complex

The constructors allow for implicit construction, making a copy, implicit conversion from float, and explicit initialization from two float values.

=, !=

Compares two complex values.

=, +=, -=, *=, /=

Assign and compound assignment of complex values.

+, -, *, /

Math operators on complex values.

abs

Returns the absolute (magnitude) of the complex value.

r, i

Retrieves the real and imaginary part of the complex value.

ri, ir

Swizzle operators return a complex value with the ordering of the real and imaginary parts as indicated by the name.