Jholsenback: typo

2017-07-26T10:48:01Z

typo

Jholsenback: 1 revision: Reference Migration Initial Load

2012-03-15T19:07:27Z

1 revision: Reference Migration Initial Load

Jholsenback: 1 revision: Initial Load (TF)

2012-03-11T22:31:20Z

1 revision: Initial Load (TF)

New page

[[Category:Include Files]]
This file contains many general math functions and macros.

====Float functions and macros====
{{#indexentry:even}}
<code>even(N)</code>: A function to test whether N is even, returns 1 when true, 0 when false.
Parameters:
<ul>
<li><code>N</code> = Input value</li>
</ul>

{{#indexentry:odd}}
<code>odd(N)</code>: A function to test whether N is odd, returns 1 when true, 0 when false.
Parameters:
<ul>
<li><code>N</code> = Input value</li>
</ul>

{{#indexentry:Interpolate, macro}}
<code>Interpolate(GC, GS, GE, TS, TE, Method)</code>: Interpolation macro, interpolates between the float values <code>TS</code> and <code>TE</code>. The method of interpolation is cosine, linear or exponential. The position where to evaluate the interpolation is determined by the position of <code>GC</code> in the range <code>GS</code> - <code>GE</code>. See the example below.
Parameters:
<ul>
<li><code>GC</code> = global current, float value within the range GS - GE</li>
<li><code>GS</code> = global start</li>
<li><code>GE</code> = global end</li>
<li><code>TS</code> = target start</li>
<li><code>TE</code> = target end</li>
<li><code>Method</code> = interpolation method, float value:
<ul>
<li><code>Method</code> < 0 : exponential, using the value of Method as exponent.</li>
<li><code>Method</code> = 0 : cosine interpolation.</li>
<li><code>Method</code> > 0 : exponential, using the value of Method as exponent.
<ul>
<li><code>Method</code> = 1 : linear interpolation,</li>
</ul></li>
</ul></li>
</ul>

Example:

<pre>
#declare A = Interpolate(0.5, 0, 1, 0, 10, 1);
#debug str(A,0,2)
// result A = 5.00

#declare A = Interpolate(0.0,-2, 2, 0, 10, 1);
#debug str(A,0,2)
// result A = 5.00

#declare A = Interpolate(0.5, 0, 1, 0, 10, 2);
#debug str(A,0,2)
// result A = 2.50
</pre>

{{#indexentry:Mean}}
<code>Mean(A)</code>: A macro to compute the average of an array of values.
Parameters:
<ul>
<li><code>A</code> = An array of float or vector values.</li>
</ul>

{{#indexentry:Std_Dev}}
<code>Std_Dev(A, M)</code>: A macro to compute the standard deviation.
Parameters:
<ul>
<li><code>A</code> = An array of float values.</li>
<li><code>M</code> = Mean of the floats in the array.</li>
</ul>

{{#indexentry:GetStats}}
<code>GetStats(A)</code>: This macro declares a global array named <code>StatisticsArray</code> containing: N, Mean, Min, Max, and Standard Deviation
Parameters:
<ul>
<li><code>A</code> = An array of float values.</li>
</ul>

{{#indexentry:Histogram}}
<code>Histogram(ValArr, Intervals)</code>: This macro declares a global, 2D array named <code>HistogramArray</code>. The first value in the array is the center of the interval/bin, the second the number of values in that interval.
Parameters:
<ul>
<li><code>ValArr</code> = An array with values.</li>
<li><code>Intervals</code> = The desired number of intervals/bins.</li>
</ul>

{{#indexentry:sind}}
{{#indexentry:cosd}}
{{#indexentry:tand}}
{{#indexentry:asind}}
{{#indexentry:acosd}}
{{#indexentry:atand}}
{{#indexentry:atan2d}}
<code>sind(v), cosd(v), tand(v), asind(v), acosd(v), atand(v), atan2d(a, b)</code>: These functions are versions of the
trigonometric functions using degrees, instead of radians, as the angle unit.
Parameters:
<ul>
<li>The same as for the analogous built-in trig function.</li>
</ul>

{{#indexentry:max3}}
<code>max3(a, b, c)</code>: A function to find the largest of three numbers.
Parameters:
<ul>
<li><code>a, b, c</code> = Input values.</li>
</ul>

{{#indexentry:min3}}
<code>min3(a, b, c)</code>: A function to find the smallest of three numbers.
Parameters:
<ul>
<li><code>a, b, c</code> = Input values.</li>
</ul>

{{#indexentry:f_sqr}}
<code>f_sqr(v)</code>: A function to square a number.
Parameters:
<ul>
<li><code>v</code> = Input value.</li>
</ul>

{{#indexentry:sgn}}
<code>sgn(v)</code>: A function to show the sign of the number. Returns -1 or 1 depending on the sign of v.
Parameters:
<ul>
<li><code>v</code> = Input value.</li>
</ul>

{{#indexentry:clip}}
<code>clip(V, Min, Max)</code>: A function that limits a value to a specific range, if it goes outside that range it is clipped. Input values larger than <code>Max</code> will return <code>Max</code>, those less than <code>Min</code> will return <code>Min</code>.
Parameters:
<ul>
<li><code>V</code> = Input value.</li>
<li><code>Min</code> = Minimum of output range.</li>
<li><code>Max</code> = Maximum of output range.</li>
</ul>

{{#indexentry:clamp}}
<code>clamp(V, Min, Max)</code>: A function that limits a value to a specific range, if it goes outside that range it is clamped to this range, wrapping around. As the input increases or decreases outside the given range, the output will
repeatedly sweep through that range, making a sawtooth waveform.
Parameters:
<ul>
<li><code>V</code> = Input value.</li>
<li><code>Min</code> = Minimum of output range.</li>
<li><code>Max</code> = Maximum of output range.</li>
</ul>

{{#indexentry:adj_range}}
<code>adj_range(V, Min, Max)</code>: A function that adjusts input values in the range [0, 1] to a given range. An input value of 0 will return <code>Min</code>, 1 will return <code>Max</code>, and values outside the [0, 1] range will be linearly extrapolated (the graph will continue in a straight line).
Parameters:
<ul>
<li><code>V</code> = Input value.</li>
<li><code>Min</code> = Minimum of output range.</li>
<li><code>Max</code> = Maximum of output range.</li>
</ul>

{{#indexentry:adj_range2}}
<code>adj_range2(V, InMin, InMax, OutMin, OutMax)</code>: Like <code>f_range()</code>, but adjusts input values in the range <code>[InMin, InMax]</code> to the range <code>[OutMin, OutMax]</code>.
Parameters:
<ul>
<li><code>V</code> = Input value.</li>
<li><code>InMin</code> = Minimum of input range.</li>
<li><code>InMax</code> = Maximum of input range.</li>
<li><code>OutMin</code> = Minimum of output range.</li>
<li><code>OutMax</code> = Maximum of output range.</li>
</ul>

====Vector functions and macros====
These are all macros in the current version because functions can not take vector parameters, but this may change in the future.
{{#indexentry:VSqr}}
<code>VSqr(V)</code>: Square each individual component of a vector, equivalent to <code>V*V</code>.
Parameters:
<ul>
<li><code>V</code> = Vector to be squared.</li>
</ul>

{{#indexentry:VPow}}
{{#indexentry:VPow5D}}
<code>VPow(V, P), VPow5D(V, P)</code>: Raise each individual component of a vector to a given power.
Parameters:
<ul>
<li><code>V</code> = Input vector.</li>
<li><code>P</code> = Power.</li>
</ul>

{{#indexentry:VEq}}
<code>VEq(V1, V2)</code>: Tests for equal vectors, returns true if all three components of <code>V1</code>equal the respective components of <code>V2</code>.
Parameters:
<ul>
<li><code>V1, V2</code> = The vectors to be compared.</li>
</ul>

{{#indexentry:VEq5D}}
<code>VEq5D(V1, V2)</code>: A 5D version of <code>VEq()</code>. Tests for equal vectors, returns true if all 5 components of <code>V1 </code>equal the respective components of <code>V2</code>.
Parameters:
<ul>
<li><code>V1, V2</code> = The vectors to be compared.</li>
</ul>

{{#indexentry:VZero}}
<code>VZero(V)</code>: Tests for a < 0, 0, 0> vector.
Parameters:
<ul>
<li><code>V</code> = Input vector.</li>
</ul>

{{#indexentry:VZero5D}}
<code>VZero5D(V)</code>: Tests for a < 0, 0, 0, 0, 0> vector.
Parameters:
<ul>
<li><code>V</code> = Input vector.</li>
</ul>

{{#indexentry:VLength5D}}
<code>VLength5D(V)</code>: Computes the length of a 5D vector.
Parameters:
<ul>
<li><code>V</code> = Input vector.</li>
</ul>

{{#indexentry:VNormalize5D}}
<code>VNormalize5D(V)</code>: Normalizes a 5D vector.
Parameters:
<ul>
<li><code>V</code> = Input vector.</li>
</ul>

{{#indexentry:VDot5D}}
<code>VDot5D(V1, V2)</code>: Computes the dot product of two 5D vectors. See vdot() for more information on dot products.
Parameters:
<ul>
<li><code>V</code> = Input vector.</li>
</ul>

{{#indexentry:VCos_Angle}}
<code>VCos_Angle(V1, V2)</code>: Compute the cosine of the angle between two vectors.
Parameters:
<ul>
<li><code>V1, V2</code> = Input vectors.</li>
</ul>

{{#indexentry:VAngle}}
<code>VAngle(V1, V2), VAngleD(V1, V2)</code>: Compute the angle between two vectors. <code>VAngle()</code> returns the angle in radians, <code>VAngleD()</code> in degrees.
Parameters:
<ul>
<li><code>V1, V2</code> = Input vectors.</li>
</ul>

{{#indexentry:VRotation}}
<code>VRotation(V1, V2, Axis)</code> and <code>VRotationD(V1, V2, Axis)</code>: Compute the rotation angle from V1 to V2 around Axis. Axis should be perpendicular to both V1 and V2. The output will be in the range between -pi and pi radians or between -180 degrees and 180 degrees if you are using the degree version. However, if Axis is set to <0,0,0> the output will always be positive or zero, the same result you will get with the VAngle() macros.
Parameters:
<ul>
<li><code>V1, V2</code> = Input vectors.</li>
</ul>

{{#indexentry:VDist}}
<code>VDist(V1, V2)</code>: Compute the distance between two points.
Parameters:
<ul>
<li><code>V1, V2</code> = Input vectors.</li>
</ul>

{{#indexentry:VPerp_To_Vector}}
<code>VPerp_To_Vector(V)</code>: Find a vector perpendicular to the given vector.
Parameters:
<ul>
<li><code>V</code> = Input vector.</li>
</ul>

{{#indexentry:VPerp_To_Plane}}
<code>VPerp_To_Plane(V1, V2)</code>: Find a vector perpendicular to both given vectors. In other words, perpendicular to the plane defined by the two input vectors.
Parameters:
<ul>
<li><code>V1, V2</code> = Input vectors.</li>
</ul>

{{#indexentry:VPerp_Adjust}}
<code>VPerp_Adjust(V1, Axis)</code>: Find a vector perpendicular to Axis and in the plane of V1 and Axis. In other words, the new vector is a version of V1 adjusted to be perpendicular to Axis.
Parameters:
<ul>
<li><code>V1, Axis</code> = Input vectors.</li>
</ul>

{{#indexentry:VProject_Plane}}
<code>VProject_Plane(V1, Axis)</code>: Project vector V1 onto the plane defined by Axis.
Parameters:
<ul>
<li><code>V1</code> = Input vectors.</li>
<li><code>Axis</code> = Normal of the plane.</li>
</ul>

{{#indexentry:VProject_Axis}}
<code>VProject_Axis(V1, Axis)</code>: Project vector V1 onto the axis defined by Axis.
Parameters:
<ul>
<li><code>V1, Axis</code> = Input vectors.</li>
</ul>

{{#indexentry:VMin}}
<code>VMin(V), VMax(V)</code>: Find the smallest or largest component of a vector.
Parameters:
<ul>
<li><code>V</code> = Input vector.</li>
</ul>

{{#indexentry:VWith_Len}}
<code>VWith_Len(V, Len)</code>: Create a vector parallel to a given vector but with a given length.
Parameters:
<ul>
<li><code>V</code> = Direction vector.</li>
<li><code>Len</code> = Length of desired vector.</li>
</ul>

====Vector Analysis====
{{#indexentry:SetGradientAccuracy}}
<code>SetGradientAccuracy(Value)</code>: All the macros below make use of a constant named __Gradient_Fn_Accuracy_ for numerical approximation of the derivatives. This constant can be changed with the macro, the default value is 0.001.

{{#indexentry:fn_Gradient}}
<code>fn_Gradient(Fn)</code>: A macro calculating the gradient of a function as a function.
Parameters:
<ul>
<li><code>Fn</code> = function to calculate the gradient from.</li>
</ul>

Output: the length of the gradient as a function.


{{#indexentry:fn_Gradient_Directional}}
<code>fn_Gradient_Directional(Fn, Dir)</code>: A macro calculating the gradient of a function in one direction as a function.
Parameters:
<ul>
<li><code>Fn</code> = function to calculate the gradient from.</li>
<li><code>Dir</code> = direction to calculate the gradient.</li>
</ul>

Output: the gradient in that direction as a function.


{{#indexentry:fn_Divergence}}
<code>fn_Divergence(Fnx, Fny, Fnz)</code>: A macro calculating the divergence of a (vector) function as a function.
Parameters:
<ul>
<li><code>Fnx, Fny, Fnz</code>= x, y and z components of a vector function.</li>
</ul>

Output: the divergence as a function.


{{#indexentry:vGradient}}
<code>vGradient(Fn, p0)</code>: A macro calculating the gradient of a function as a vector expression.
Parameters:
<ul>
<li><code>Fn</code> = function to calculate the gradient from.</li>
<li><code>p0</code> = point where to calculate the gradient.</li>
</ul>

Output: the gradient as a vector expression.


{{#indexentry:vCurl}}
<code>vCurl(Fnx, Fny, Fnz, p0)</code>: A macro calculating the curl of a (vector) function as a vector expression.
Parameters:
<ul>
<li><code>Fnx, Fny, Fnz</code> = x, y and z components of a vector function.</li>
<li><code>p0</code> = point where to calculate the gradient.</li>
</ul>

Output: the curl as a vector expression


{{#indexentry:Divergence}}
<code>Divergence(Fnx, Fny, Fnz, p0)</code>: A macro calculating the divergence of a (vector) function as a float expression.
Parameters:
<ul>
<li><code>Fnx, Fny, Fnz</code> = x, y and z components of a vector function.</li>
<li><code>p0</code> = point where to calculate the gradient.</li>
</ul>

Output: the divergence as a float expression.


{{#indexentry:Gradient_Length}}
<code>Gradient_Length(Fn, p0)</code>: A macro calculating the length of the gradient of a function as a float expression.
Parameters:
<ul>
<li><code>Fn</code> = function to calculate the gradient from.</li>
<li><code>p0</code> = point where to calculate the gradient.</li>
</ul>

Output: the length of the gradient as a float expression.


{{#indexentry:Gradient_Directional}}
<code>Gradient_Directional(Fn, p0, Dir)</code>: A macro calculating the gradient of a function in one direction as a float expression.
Parameters:
<ul>
<li><code>Fn</code> = function to calculate the gradient from.
<li><code>p0</code> = point where to calculate the gradient.
<li><code>Dir</code> = direction to calculate the gradient.
</ul>

Output: the gradient in that direction as a float expression

@@ Line 154: / Line 154: @@
 {{#indexentry:adj_range2}}
-<p><code>adj_range2(V, InMin, InMax, OutMin, OutMax)</code>: Like <code>f_range()</code>, but adjusts input values in the range <code>[InMin, InMax]</code> to the range <code>[OutMin, OutMax]</code>.</p>
+<p><code>adj_range2(V, InMin, InMax, OutMin, OutMax)</code>: Like <code>adj_range()</code>, but adjusts input values in the range <code>[InMin, InMax]</code> to the range <code>[OutMin, OutMax]</code>.</p>
 <p>Parameters:</p>
 <ul>

← Older revision	Revision as of 19:07, 15 March 2012
(No difference)

Reference:Math.inc - Revision history

Jholsenback: typo

Jholsenback: 1 revision: Reference Migration Initial Load

Jholsenback: 1 revision: Initial Load (TF)