This constant change degrees to radians : Math.PI/180.

Represents the smallest positive Single value greater than zero.

This constant is the Euler-Mascheroni constant (lambda or C) :

    ( n )
    lim( sigma 1/k - ln(n) )
    n->oo ( k=1 )
    

This constant is the golden ratio (phi) : ( 1 + Math.sqrt(5) ) / 2.

This constant change radians to degrees : 180/Math.PI.

Returns the inverse cosine of a slope ratio and returns its angle in degrees.

Anti-hyperbolic cosine.

     acoshm = ln(x-√(x^2-1))
     

Anti-hyperbolic cosine.

     acoshp = ln(x+√(x^2-1))
     

Returns the angle in degrees between 2 points with this coordinates passed in argument.

Calculates the arcsine of the passed angle.

Anti-hyperbolic sine.

Calculates the arctangent2 of the passed angle.

Calculates the arctangent of the passed angle.

Anti-hyperbolic tangent.

Short for 'boing-like interpolation', this method will first overshoot, then waver back and forth around the end value before coming to a rest.

Example :

     import core.maths.berp ;
     trace( berp( 0 , 100 , 0.5 ) ; 
     

Returns a value between 0 and 1 that can be used to easily make bouncing GUI items (a la OS X's Dock)

Example :

     import core.maths.bounce ;
     trace( bounce( 0.5 ) ) ; 
     

Converts a vector in cartesian in a polar vector. Return a generic object with the properties angle and radius.

Rounds and returns the ceiling of the specified number or expression. The ceiling of a number is the closest integer that is greater than or equal to the number.

Example :

     import core.maths.ceil ;
     
     var n:Number ;
     
     n = ceil(4.572525153, 2) ;
     trace ("n : " + n) ; // n : 4.58
     
     n = ceil(4.572525153, -1) ;
     trace ("n : " + n) ; // n : 5
     

Bounds a numeric value between 2 numbers.

Example :

     import core.maths.clamp ;
     
     var n:Number ;
     
     n = clamp(4, 5, 10) ;
     trace ("n : " + n) ; // 5
     
     n = clamp(12, 5, 10) ;
     trace ("n : " + n) ; // 10
     
     n = clamp(6, 5, 10) ;
     trace ("n : " + n) ; // 5
     
     var n = clamp(NaN, 5, 10) ;
     trace ("n : " + n) ; // NaN
     

Circular Lerp is like lerp but handles the wraparound from 0 to 360. This is useful when interpolating eulerAngles and the object crosses the 0/360 boundary. The standard Lerp function causes the object to rotate in the wrong direction and looks stupid, clerp() fixes that.

Example :

     import core.maths.clerp ;
     trace( clerp( 0 , 180 , 0.5 ) ; // 90
     

Calculates the cosine of the passed angle.

Hyperbolic cosine.

Short for 'cosinusoidal interpolation', this method will interpolate while easing around the end, when value is near one.

Example :

     import core.maths.coserp ;
     trace( coserp( 0 , 100 , 0.5 ) ;
     

Converts an angle in degrees in radians

Returns the distance between 2 points with the coordinates of the 2 points.

Returns the distance between 2 points with the coordinates of the 2 points.

Fixs an angle in degrees between 0 and 360 degrees.

Rounds and returns a number by a count of floating points.

Example :

     import core.maths.floor ;
     
     var n:Number ;
     
     n = floor(4.572525153, 2) ;
     trace ("n : " + n) ; // n : 4.57
     
     n = floor(4.572525153, -1) ;
     trace ("n : " + n) ; // n : 4
     

Returns the greatest common divisor with the Euclidean algorithm.

Example :

     import core.maths.gcd ;
     
     trace("gcd(320,240) : " + gcd(320,240) ) ; // gcd(320,240) : 80
     

This method will interpolate while easing in and out at the limits.

Example :

     import core.maths.hermite ;
     trace( hermite( 0 , 100 , 0.5 ) ; // 50
     

Calculates the hypothenuse value of the two passed-in triangle sides value.

A hypotenuse is the longest side of a right triangle (Right-angled triangle in British English), the side opposite the right angle. The length of the hypotenuse of a right triangle can be found using the Pythagorean theorem, which states that the square of the length of the hypotenuse equals the sum of the squares of the lengths of the other two sides.

With a number value and a range this method returns the actual value for the interpolated value in that range.

     import core.maths.interpolate ;
     
     trace( interpolate( 0.5, 0 , 100 ) ) ; // 50
     

Indicates if an integer that is "evenly divisible" by 2.

Indicates if an integer that is not "evenly divisible" by 2.

Calculates a number between two numbers at a specific increment. The lerp function is convenient for creating motion along a straight path and for drawing dotted lines.

Lerp is an abbreviation for linear interpolation, which can also be used as a verb (Raymond 2003).

Linear interpolation is a method of curve fitting using linear polynomials. It is heavily employed in mathematics (particularly numerical analysis), and numerous applications including computer graphics. It is a simple form of interpolation.

Example :

     import core.maths.lerp ;
     trace( lerp( 0 , 100 , 0.5 ) ; // 50
     

Calculates the log10 of the specified value.

Calculates the logN of the specified value.

Takes a value in a given range (minimum1, maximum1) and finds the corresponding value in the next range(minimum2, maximum2).

     import core.maths.map ;
     
     trace( map( 10,  0, 100, 20, 80  ) ) ; // 26
     trace( map( 26, 20,  80,  0, 100 ) ) ; // 10
     

Takes a value within a given range and converts it to a number between 0 and 1. Actually it can be outside that range if the original value is outside its range.

     import core.maths.normalize ;
     
     trace( normalize( 10, 0 , 100 ) ) ; // 0.1
     

Returns a percentage or null.

Example :

     import core.maths.percentage ;
     
     trace( percentage( 50 , 100 ) + "%" ) ; // 50%
     trace( percentage( 68 , 425 ) + "%" ) ; // 16% 
     

Converts a Polar object in a cartesian vector.

Converts an angle in radians in degrees

Replace the passed-in Number value, if the value is NaN the return value is the default value in second argument.

Rounds and returns a number by a count of floating points.

Example :

     import core.maths.round ;
     
     var n:Number ;
     
     n = round(4.572525153, 2) ;
     trace ("n : " + n) ; // 4.57
     
     var n = round(4.572525153, -1) ;
     trace ("n : " + n) ; // 5
     

Returns 1 if the value is positive or -1.

Example :

     import core.maths.sign ;
     
     var n:int ;
     
     n = sign(-150) ;
     trace ("n : " + n) ; // -1
     
     n = sign(200) ;
     trace ("n : " + n) ; // 1
     
     n = sign(0) ;
     trace ("n : " + n) ; // 1
     

Calculates the sine of the passed angle.

Hyperbolic sine.

Short for 'sinusoidal interpolation', this method will interpolate while easing around the end, when value is near one.

Example :

     import core.maths.sinerp ;
     trace( sinerp( 0 , 100 , 0.5 ) ;
     

Calculates the tangent of the passed angle.

Hyperbolic tangent.