//----------------------------//
ArtMatic 1 in 1 out components
//----------------------------//

11 components are scalar (single output) functions. Most of them act as filters that modulate or remap the incoming values. They also provide basic building blocks for implementing your own algorithms and formulas. In many cases, the component's name is the calculation performed by the component. An essential in-depth discussion of ArtMatic structures Trees and components is found in ArtMatic Designer References and in Building trees.
In the discussion below, x signifies the tile's input value. It is often useful to insert 11 components between other components (and at the end of the tree) in order to adjust individual value 'streams'.

11 Set Constant

ArtMatic script function :Constant

parameters :
A : value (-16.0 : 16.0) E9 options

discussion :
This component returns a constant value set by parameters regardless of the input value. The options popup provides three interpretations of parameter A: direct value, 1/value, angle in degree. When direct value is selected, the output value is the setting of parameter A. When the 1/value option is used, the output is 1 divided by the parameter A value. When the angle in degrees option is selected, parameter A is treated as a value in degrees, and the output value is the equivalent value expressed in radians.

• Set (constant):
  script call : Constant.any
  return a single constant value
  
• unity (constant):
  script call : Constant.unit
  return a single constant value in the unit range -1 : 1
  
• color (Packed):
  script call : Constant.color
  Defines a Color, returned as a packed RGB vector. In that case the slider will range 0-1 and the UI will display the corresponding color
  
• normalised vector (Packed):
  script call : Constant.normalized
  Defines a normalised vector (magnitude==1) using the 'x','y' and 'z' parameters.
  
• VY sun light vector (Packed):
  script call : Constant.vy_sun
  Returns the Voyager sun light direction as a packed 3D vector. With the sun light vector we can compute the sun coordinates in the sky dome easily. Note the sky dome is a sphere of Pi*2 radius. The constant "Packed VY sun light vector" has a magnitude parameter that shall be set to Pi*2 (maximum) so this will give the center of the sun projected on the sky dome. Subtract it from the input coordinate and you get a vector in sun coordinates where zero is the sun center. That way you can create any shaders for the sun easily.
  
• VY eye position (Packed):
  script call : Constant.vy_eye
  Returns the Voyager camera eye coordinates. You may use this vector in Voyager for cool special effects like terrains features or objects/lights that will move along with the camera. Subtract this vector to an ArtMatic DF object coordinates to ensure the object position is relative to Voyager camera position. The eye position is also available in unpacked form with the 13 Set Constant component.
  
• RGBA constant (Packed):
  script call : Constant.rgba
  Defines a RGBA Color returned as a packed RGBA vector. In that case the RGB sliders will range 0-1 and the UI will display the corresponding RGB color. The alpha can be set from -1 to 1 for more flexibility.
  
• Plane Vector (Packed):
  script call : Constant.planes
  + the packing component.
  
• Vector (Packed):
  script call : Constant.vec4
  comment
  

• x*x :
  script call : Maths.square
  x-squared.
  
• sqrt(x) :
  script call : Maths.sqrt
  Square root of x. If x<0, the output is 0
  
• log(x) :
  script call : Maths.log
  Natural log of x. Infinity when x<=0
  
• exp(x) :
  script call : Maths.exp
  e^x. Remember exp is the inverse of log.
  
• gauss : exp(-x*x) :
  script call : Maths.gauss
  Gaussian curve
  
  
  
• x/Pi :
  script call : Maths.x_div_pi
  
  Divides input by Pi. Useful for music/sound application to tune unity-based functions to semitones pitch base. Far example "unit saw " (or saw wave with freq 1) can be tuned to same frequency as the sine wave just by adding the x/Pi above.
  
• x*Pi :
  script call : Maths.x_mul_pi
  Multiplies input by Pi.
  


• sin(x) :
  script call : Maths.sin
  Simple sine function.
  
• cos(x) :
  script call : Maths.cos
  Simple cosine function.
  
• tan(x):
  script call : Maths.tan
  Arctangent.
  
• acos(x) :
  script call : Maths.acos
  Inverse of cosine function : ArcCos(x). The input values are 'tiled' to the range -1 to 1.
  
• asin(x) :
  script call : Maths.asin
  Inverse of sine function. The input values are 'tiled' to the range -1 to 1.
  
• atan(x) :
  script call : Maths.atan
  Returns the Inverse of tan(x) : ArcTangent(x).
  
• hyperbolic tan :
  script call : Maths.tanh
  Returns the Hyperbolic Tangent(x) of input x.
  


• zero floor (x+) :
  script call : Maths.zero_floor
  x is limited to values from 0 through infinity. If x<0, the output is 0.
  
• smooth zero floor (x+) :
  script call : Maths.smooth_floor
  x is limited to values from 0 through infinity. using a smooth max (x,0).
  
• smooth zero roof (x-) :
  script call : Maths.smooth_roof
  x is limited to values from - infinity to 0 using a smooth min (x,0).
  
• clamp unity :
  script call : Maths.clamp_unity
  clamp(x,0,1) Make sure output stays in 0 -1 range.
  
• cubic unity :
  script call : Maths.cubic_unity
  Cubic spline of x from 0 - 1 using (x*(x*(3-x-x))).
  
• cubic unity neg (x-) :
  Similar to the cubic unity algorithm (a cubic envelope limiting values to the range 0-1) but acting on on the negative part of x-axis.
  
• N*int(x):
  script call : Maths.int
  Returns the integer part of input multiplied by first parameter. For example 2*int(x) will return the sequence 0 2 4 6 8 etc. the function is useful for indexing manipulation or to output a discontinuous step function.
  Note that x-int(x) is equivalent to fract(x)
  Example:Libraries/Components 8.5/PictAtlas/InfiniteZoomAtlas.artm
  
• unit mod (fract(x)):
  script call : Maths.fract
  Returns the fractional part of the input which is equivalent to modulus1. Modulus has a sharp discontinuity when signal jumps from max to min.
  Sound-wise it is a saw tooth signal that has a rich frequency content.
  
• unit saw :
  script call : Maths.unitsaw
  Unbalanced unit (from 0 to 1)triangle wave.
  
• unit smooth saw :
  script call : Maths.unitsaw_smooth
  Unbalanced unit (from 0 to 1) triangle wave with smoothed edges.
  
• balanced unit mod :
  script call : Maths.fract_balanced
  Balanced modulus from -1 to 1. When the input is 0, the output is 0. This is a classic ramp wave.
  
• balanced unit saw :
  script call : Maths.unitsaw_balanced
  Balanced unit (from -1 to 1) triangle wave.
  
• balanced smooth saw :
  script call : Maths.unitsaw_smooth_balanced
  Balanced unit (from -1 to 1) saw wave with smoothed edges.
  


• slab : N-abs(x) :
  script call : Maths.slab
  Returns a triangle envelope where peak N is located at input x =zero and sides goes linearly towards minus infinity.
  Since 1.5 N-abs supports a smooth parameter that can smooth out the sharp edges at zero. For DF modeling N-abs(x) creates a infinite line of width N that can be used as a intersecting profile.
  
• unit slab:
  script call : Maths.unit_slab
  Returns a triangle envelope whose peak is clamped to 1. When N is above 1 it will create a trapezoidal profile.
  
• dent abs:
  script call : Maths.dent_abs
  Returns the minimum of x and a inverse triangle envelope (peak pointing down). When N is at zero the 'dent" disappears and x is left unchanged.
  
• sign(x):
  This algorithm aborts iterations within a recursive compiled tree when the input value is larger than 32. This can be used to optimise certain fractals by aborting meaningless (and time-consuming) iterations.
  


• iteration break (|x|>32):
  script call : Maths.iteration_break
  This algorithm aborts iterations within a recursive compiled tree when the input value is larger than 32. This can be used to optimise certain fractals by aborting meaningless (and time-consuming) iterations.
  

Note : Use the 'Utility function plot" tree to see the plot of each function.

ArtMatic script function :Affine

parameters :
A : Scale (-20.0 : 20.0) E9 options
B : Offset (-32.0 : 32.0) E9 options

discussion :
This linear scaling component multiplies the input with parameter A then adds an offset (parameter B). It is nice for adjusting the contrast and level of a system. When the input is packed it will process the RGB channels and return a packed vector of same dimension.

In E9 Parameter options are now settable for each parameters. When 'direct value' is selected, the output value is simply the setting of parameter A.
When the '1/value' parameter option is used, the output is 1 divided by the parameter A value.
When 'angle in degrees' is chosen, parameter A is treated as a value in degrees and the output value is equivalent value expressed in radians. The angle in degrees option is convenient for multiplying by Pi (180 degrees) or Pi/n. The range of 'Offset' parameter goes then from -180 to 180.
The option 'semitones' is useful for sound synthesis. It sets A to exp(A*log(2)/12) which is the ratio of a temperated scale semitone A. By scaling the input of a wave tuned to default you can transpose the pitch by semitones with zero being the fundamental, 2 one tone above, -3 a minor third below. A needs to be an integer to obtain a real semitone frequency. Of course the tuning will be relative to the fundamental frequency, so make sure it is set to a known value (Preferences dialog gives the tuning of a sine at frequency 1 in semitones where A0 is 441 hertz).

ArtMatic script function :Offset

parameters :
A : Offset (-64.0 : 64.0) E9 options

discussion :
Adds a value supplied by the Offset parameter to the incoming value. When the input is packed it will process the RGB channels and return a packed vector of same dimension.
This component has various parameter options to adjust the range or nature of the offset: direct value, 1/value, angle in degrees, value *10 and value *20, value /10 and value /20. The last options are handy for larger or smaller displacements. When 'angle in degrees' is chosen the range of 'Offset' parameter goes from -180 to 180, which is -Π to Π.

ArtMatic script function :Reverse

parameters :
A : Level (0.0 : 20.0) E9 options

discussion :
This component revert the direction of the input values. When A is zero, this component just returns the negative of the input.
There are various parameter options to adjust the range or nature of parameter A:  direct value, 1/value, angle in degrees, value *10 and value *20, value /10 and value /20.
For example to obtain exactly Π-x you will set the option to "angle in degrees" and use 180 for parameter A.

ArtMatic script function :Inverse

parameters :
A : Amplitude (-10.0 : 10.0) E9 options

discussion :
A/x returns the inversion of the input scaled by A. Note that with x close to zero the output will tend to infinity.

• inverse 1/x :
  
  inverse 1/x.: returns A/x where A is the value of parameter slider A and x is the input value.
  
• contours : 1/abs(x):
  returns A/abs(x) instead of A/x. This algorithm is great for neon effects as the light will slowly vanish when x increases and is symmetrical around zero.
  

ArtMatic script function :Abs

parameters :
A : Offset (-32.0 : 32.0) E9 options

discussion :
Returns the absolute value of the input (i.e. it strips the minus sign from the input) plus the value of parameter A. When applied to a space coordinate, Abs X will create a mirror symmetry. The various options allows to orient the mirroring and change the range of the offsets parameters.
Formula: |x| + A or A -|x| depending on mirror orientation.

ArtMatic script function :Smooth_Abs

parameters :
A : Smoothness % (0.4 : 8.0)
B : Offset (-32.0 : 32.0) E9 options
C : Phase (-10.0 : 10.0) E9 options

discussion :
This is a modified version of the absolute value function which is smoothed near the origin. 'Smoothness' controls the degree of smoothing while 'Offset' offsets the result after the absolute value. The 'Phase' parameter, introduced in ArtMatic Engine 8.0, offsets the input prior the absolute value. This is often handy to adjust the position of the mirror if the input is not balanced. The various options allows to orient the mirroring and change the range of the offsets parameters.
Formula: smoothAbs(x+C) + A or A -smoothAbs(x+C) depending on mirror orientation.

ArtMatic script function :Mirror

parameters :
A : Scaling (0.0 : 4.0)
B : Offset (-32.0 : 32.0) E9 options
C : Smoothing % (0.0 : 4.0)

discussion :
A symmetry component that creates a mirror of the input values. The Offset parameter moves the mirror axis. Parameter A scales the output value and should be kept at 1 for a true mirroring. Formula: if (x>B) then y = 2 * B - x

ArtMatic script function :Gaussian

parameters :
A : Scale (0.0 : 128.0) E9 options
B : Phase (-16.0 : 16.0) E9 options
C : Amplitude (0.0 : 8.0)

discussion :
The Gaussian tile returns a bell curve. The output of a Gaussian function at 0 is 1 and approaches 0 when A(x+B) is greater than 2. To increase the width of the bell curve, decrease parameter A. The curve is symmetrical around x=0. Formula: C exp(-X²) where X is A(x+B), or Ce^-Axx

• Scaled power (x^A)/(B^A):
  
  Parameter B is applied as an additional scaling factor. If the incoming value is negative, the absolute value is taken before applying the function, keeping the same sign.
  When A & B are positive Scaled power is equivalent to (x/B)^A.
  
• Power+ (x^A):
  
  Straight power on the positive domain (negative inputs floored to 0).
  
• Affine+ Bx^A+C:
  
  (E9 addition) Straight power with scaling and offset. Handy for script direct math parsing of expression like a*X^N+b, or a square polynomial when A==2
  

ArtMatic script function :Apow

parameters :
A : A (0.0 : 10.0) E9 options
B : Amplitude (0.0 : 2.0) E9 options

discussion :
This tile provides another basic math building block that returns the parameter A raised to x (input) power. When A is 1 the result is constant 1 while A<1 reverse the slope of input.
Note that when A is set to e (2.7182818284) the function is equivalent to exp(x);
Formula : B A^x

discussion :
This filter applies the natural log to the input. It is good for decreasing the output range of functions that go to infinity. The amount parameter determines the steepness of the output curve.
Note that negative input are clamped to (1/80000) to avoid infinities (log goes to -inf at 0 and is undefined in negatives).
Example : 2*log(0.5x)

ArtMatic script function :Cubic_polynomial

parameters :
A : A (-10.0 : 10.0) E9 options
B : B (-10.0 : 10.0) E9 options
C : C (-10.0 : 10.0) E9 options
D : D (-10.0 : 10.0) E9 options

discussion :
Available starting E9 Cubic polynomial implements cubic equations (polynomials of degree 3) of the form Ax^3+Bx^2+Cx+D, (A,B,C,D being constants)
Example : Libraries/Examples 9.0/Plot11 #cubicpoly.artm

Script language example : 2x^3+3x^2+x+0.5 <=>Cubic_polynomial(X) with parameters (2 3 1 0.5)

11 Envelopes #

ArtMatic script function :Envelopes

parameters :
A : Peak point % (0.0 : 1.0)
B : Decay time % (0.0 : 4.0)
C : Amplitude (0.0 : 8.0)

discussion :
This component creates an envelope with a given attack and decay with various shapes. Values outside of the envelope range are mapped to zero. Thus Envelopes outputs a signal that always starts and ends at zero. This component can serve as a nice contrast or surface contour control. It can also serve as an envelope filter for sound design when multiplying its output with the sound waveform. The 'Amplitude' essentially sets the height of the saw envelope. As an envelope is often used to shape another signal 'Amplitude' is often left at 1. the Slope or 'Decay time' 'parameter sets the decay length. 'Peak point' or offset sets the attack time. The Right Slope parameter (A) may have a value less than 0. A negative slope provides a gradual attack and a rapid decay rather than the a quick attack and slow decay. In general the algorithms maps the interval 0 : 1 to the envelope and sets elsewhere to 0. All curves are continuous except saw which is linear. Note the Amplitude scales also the frequency so you can have the envelope works on the range 0-3 if you set it to 3. Some decay time (oriented saw and impulse) can be longer than the 0-1 window.

algorithms :

• Oriented saw:
  script call : Envelopes.saw
  A triangle (linear) wave with a faster attack than decay.
  
• Impulse:
  script call : Envelopes.impulse
  Now the default. parameters : peak point, decay time, amplitude.
  
• Asym power:
  script call : Envelopes.asymmetric_power
  Parameters : power left, power right, amplitude.
  
• Power decay:
  script call : Envelopes.power_decay
  Parameters : peak point, power right, amplitude.
  
• Parabola:
  script call : Envelopes.parabola
  Symmetrical. parameters : power , amplitude.
  
• Gate:
  script call : Envelopes.gate
  Sharp slope in and out envelope. parameters : slope , decay point.
  

Impulse envelope with a peak at 0.1 and a 0.45 decay time.

ArtMatic script function :Power_slope

parameters :
A : Size (0.125 : 8.0)
B : Phase (-10.0 : 10.0) E9 options
C : Power (0.125 : 16.0)
D : Amplitude (-8.0 : 8.0)

discussion :
An exponential curve with a step function-like effect except that it is continuous with rounded edges near the 'step". This function, when used at the final stage of a system, tends to make the image very high contrast -- black and white rather than shades of gray, for example.
The output ranges 0 -amplitude

discussion :
This component filters the input with an inverted Gaussian curve.
It provides a convenient way to smoothly clip values that approach infinity, as high negatives or positives input values will map to 0;

ArtMatic script function :InverseSquareOffset

parameters :
A : Amplitude (-10.0 : 10.0) E9 options
B : Offset (-10.0 : 10.0) E9 options

discussion :
This component, changed in ArMatic engine 8.06, is similar to Gaussian in the sense the result is symmetric and its maximum occurs when x is zero. It has sharp spike around origin and the fallout is a good approximation of physical system that fades according to the inverse square power of the distance. Thus it is often applied to a 21 distance function to get lights effects.
In E9 the calculation A/(x^2+B), incorporating the old -1 into the parameter value (old formula : A/(x^2+B-1)).

ArtMatic script function :Sin

parameters :
A : Amplitude (-10.0 : 10.0) E9 options
B : Phase (-10.0 : 10.0) E9 options
C : Frequency (-10.0 : 10.0) E9 options

discussion :
This component returns the sine of the input which renders its output periodic (cyclic). It is the basic primitive for pitched sounds and any periodic phenomenon. It can be used for sound creation, wood-type textures, zebra patterns and much much more.
sin has a natural period of Pi2. You may want to use the Frequency parameter along the E9 option value*Pi to match a period multiple of unity.
Example : Libraries/Examples 9.0/Sinx In Unity.artm

Script example: modulate the phase with time
vec1 rings =length(X,Y); vec1 fout1 = sin(3*rings-T)^3;

ArtMatic script function :PowerSines

parameters :
A : Frequency (-10.0 : 10.0) E9 options
B : Phase (-10.0 : 10.0) E9 options
C : Power (0.0 : 16.0) E9 options
D : Amplitude (0.0 : 4.0)

discussion :
This periodic component is useful for creating banding effects and for adding harmonics when in Sound mode. It is equivalent to passing the sin output through a power filter. 'Amplitude' scales the output amplitude while 'Frequency' scales the input.
Formula: (sin (x*A+B))^C.

• power sin (square):
  script call : PowerSines.square
  At power lower than 1 the signal converges toward a pure square wave (C=0).
  
• saw power sin (saw):
  script call : PowerSines.saw
  At power lower than 1 the signal converges toward a pure saw tooth wave (C=0).
  
• unit power sin:
  script call : PowerSines.unity
  

ArtMatic script function :Tile_wave

parameters :
A : Amplitude (0.0 : 16.0)
B : Phase (-16.0 : 16.0) E9 options
C : Frequency (0.0 : 1.0)

discussion :
A non-symmetrical sawtooth wave. Very handy for creating repetitive patterns and for creating sound waves. With default parameter values, it repeats the interval bounded by -1 and 1 which keeps the output centered about 0 (essential for musical applications). If you place a Tile Wave component before any other 1D filter, the filter will become periodic (though not necessarily continuous since the ramp drops immediately from its maximum value to its minimum value). For example, if you need a repeating figure of gaussian grains, put a Tile Wave before the Gaussian tile. Tile Wave is similar to modulo but without having the amplitude proportional to frequency.
the Frequency parameter has the usual frequency options settings. In DF modes the frequency adjust the amplitudes to make the transform compatible with DF modeling.so you can use tile wave to repeat an object on a given axis.

Sound tip: Multiply the result with a sine wave and you get rich sounds.

ArtMatic script function :Modulo

parameters :
A : Period (0.0 : 100.0) E9 options
B : Phase (-100.0 : 100.0) E9 options
C : Amplitude (0.0 : 16.0)

discussion :
Modulo returns the modulo/remainder function of input. Applied on x it will create a saw tooth signal that repeats the 0-A interval.

It is very useful when you need to repeat a pattern or create a periodic function. The balanced form can be used for DF modeling when keeping amplitude at 1. Frequency determines the spacing of the created 'ramps" (by setting the divisor used to generate the modulo). Amplitude is applied at the output stage.

• Infinite modulo balanced:
  script call : Modulo.balanced
  Balanced infinite modulo with output range (- 'Amplitude', + 'Amplitude').
  
• Infinite modulo +:
  script call : Modulo.std
  Positive only infinite modulo with output range (0, + 'Amplitude').
  
• Repeats N:
  script call : Modulo.repeats
  Limits the modulo function to a particular number of repetitions (rather than go on infinitely as it does with the default Infinite Modulo algorithm). The fourth parameter, Number of Repeats, is active for this algorithm. This algorithm is convenient for creating finite repetitions in X or Y by inserting it on the appropriate axis. 0 is in the middle of each repetition series.
  

ArtMatic script function :Saw_waves

parameters :
A : Frequency (-32.0 : 32.0) E9 options
B : Phase (-100.0 : 100.0) E9 options
C : Amplitude (-16.0 : 16.0)
D : Smoothness % (0.0 : 1.0)

discussion :
This periodic component returns a triangle wave function similar to a sine wave but with sharper edges. Saw wave is often used in sound synthesis for the richness of its harmonic content. When used on a space coordinate input, the resulting space will feature a periodic mirroring symmetry on the corresponding axis.

The repeats and Folding modes will limit the mirroring of saw to a discreet numbers of mirroring, thus a finite number of repetitions (set by parameter D) are performed. The Repeats and Folding are useful for design, architecture and kaleidoscopic 2D or 3D fractals.

For DF modeling N Fold asymmetry is particularly useful to repeat a zero centered object.


With Repeats (red curve) the result is symmetrical around zero and zero x maps to +-C
With Foldings (green curve) the space around zero is left unmodified zero x maps to 0

• Infinite saw balanced:
  script call : Saw_waves.inf_balanced
  Returns a saw wave in -Amplitude + Amplitude range.
  
• Infinite saw +:
  script call : Saw_waves.inf_positive
  Returns a saw wave in 0 - Amplitude range.
  
• Saw displace:
  script call : Saw_waves.displace
  Add the saw wave to the input.
  
• Repeats N, Hard edges:
  script call : Saw_waves.repeat
  Does a limited amount of saw repetitions given by parameter D when in this mode.
  
• Repeats N, Smooth edges:
  script call : Saw_waves.repeat_smooth
  Same as before but with smooth edges.
  
• N Fold asym:
  script call : Saw_waves.Nfold_asym
  N repeats with zero untouched. Parts before and after folding are left unchanged.
  
• N Fold smooth asym:
  script call : Saw_waves.Nfold_asym_smooth
  Same as before but with smooth edges.
  

Note : since amplitude is related to the period defined by frequency "saw wave" is DF compatible when using non Pi based options with the amplitude at 1.

11 U wave

ArtMatic script function :U_wave

parameters :
A : Frequency (0.0 : 16.0) E9 options
B : Phase (-16.0 : 16.0) E9 options
C : Amplitude (-4.0 : 4.0)

discussion :
This component is a useful u-shaped periodic wave based on the absolute value of a sine function.

ArtMatic script function :Sinc

parameters :
A : Frequency (0.0 : 10.0) E9 options
B : Phase (-10.0 : 10.0) E9 options
C : Amplitude (0.0 : 4.0)

discussion :
This tile has been reimplemented in E9 to support the real Sinc(x) function sin(x)/x. The old form x*sin(x) is still available using 'inverse' algorithm .

Script example:
vec1 fout = Sinc.std(x)+(0.3*x+Pi);

• std:
  script call : Sinc.std
  Standard sinc function sin(x)/x, ArtMatic formula : (A/x)*sin(Bx).
  
  
• inverse:
  script call : Sinc.inverse
  In inverse the amplitude of the sine wave is scaled by the input x. If the input is itself periodic, x sin(x) can be used to create interesting modulated sounds.
  Formula: A x * sin(Bx)
  
  

ArtMatic script function :HarmonicSin

parameters :
A : Frequency (-10.0 : 10.0) E9 options
B : Harmonics (0 : 64) integer
C : Amplitude (0.0 : 2.0)

discussion :
This component is great for creating harmonics for structures designed for sound synthesis (when using the Direct Drones synthesis method). The component equation is Sin(Bx)/sin(x). Amplitude determines the output amplitude. Frequency influences the harmonic spacing. Harmonics determines the number of harmonics.

ArtMatic script function :SinesCluster

parameters :
A : Frequency (-10.0 : 10.0) E9 options
B : Spread % (0.0 : 1.0)
C : Amplitude (0.0 : 2.0)

discussion :
This series generates various sounds based on the integration of 24 sines waves. Nice fuzzy and voicy sounds can be obtained with sines clusters.

• Fuzzy Harmonics:
  script call : SinesCluster.fuzzy
  Parameters : freq, spread, amplitude. Spread controls how much individual sines are detuned from the center freq.
  
• Gauss Randomized :
  script call : SinesCluster.randomized_
  Parameters : frequency, spread, amplitude. Randomisation follows a gaussian distribution.
  
• Harmonics subset gaussian:
  script call : SinesCluster.gaussian
  Parameters : frequency, spread, amplitude, harmonic offset. Integrates part of the harmonic series starting at harmonic offset with a Gaussian amplitude distribution.
  
• Harmonics subset 1/f:
  script call : SinesCluster.pinkharmo
  
  Harmonics subset 1/f Integrates part of the harmonic series starting at harmonic offset with a 1/f amplitude distribution (the higher the lower). The *2 and *3 is the spacing between harmonics. For example if H offset is 2 and H*3 is used we will get (2, 5, 8, 11… etc) for 24 sines.
  Parameters : freq, amplitude, harmonic offset.
  
• Harmonics*2 subset 1/f:
  script call : SinesCluster.pinkharmo2
  comment
  
• Harmonics*3 subset 1/f:
  script call : SinesCluster.pinkharmo3
  comment
  

discussion :
The Sphere filter yields a spherical profile when applied after the distance component in 2D. In 1D it will yield an arc envelope with values outside the radius clamped at zero.
See the 1D curve with a unit radius in Wolfram Alpha

ArtMatic script function :Step

parameters :
A : Amplitude (0.0 : 16.0) E9 options
B : start (-10.0 : 10.0) E9 options
C : end (-10.0 : 10.0) E9 options

discussion :
Step (E9) implements the standard step function. Input range B(start) to C(end) is mapped into 0:1 with optional cubic or quintic filter (using algorithm#) Values below B are kept at 0 while value above C are kept at 1 'Amplitude' scales the result to 0 and A range.

Script example: you can call Step implicitly using step(V,start,end) or sstep for the cubic version
vec1 fa = 2*sin(2*X+Pi);
vec1 out1 = step(fa,0.5,0.6);

legacy (<=E8) : Cubic clip clamps the input between 0 and 1 using a cubic spline (x*x(3-2*x)) to maintain continuity at the clipping boundaries. 'Offset' is added to the input before applying the cubic filter while 'Slope' parameter scales the input value prior the clamping. 'Amplitude' scales the result so that the final output range will be positive only and between 0 and amplitude A.

• linear:
  script call : Step.linear
  linear clipping
  
  
• cubic:
  script call : Step.cubic
  uses a cubic spline (x*x(3-2*x)) to maintain continuity at the clipping boundaries.
  
  
• quintic:
  script call : Step.quintic
  uses a quintic spline to maintain a higher continuity at the clipping boundaries.
  
  

ArtMatic script function :Clamp

parameters :
A : Contrast (0.0 : 10.0) E9 options
B : Offset (-10.0 : 10.0) E9 options
C : Cutoff (0.0 : 16.0) E9 options

discussion :
This filter clips abruptly the input scaled by contrast when it passes outside of the range from 0 to the value defined by the CutOff parameter.
For a smooth clamping use the Smooth Clamps or the step function.
In E9 the default max value (Cutoff) has been set to 1.
formula : clamp(x*A+B,0,Cutoff)

Script example:
vec1 fa = 8*sin(2*X+Y);
vec1 out1 = Clamp(fa);

ArtMatic script function :Clamps

parameters :
A : Floor level (-100.0 : 32.0) E9 options
B : Roof level (-32.0 : 100.0) E9 options
C : Smoothness % (0.0 : 8.0)

discussion :
"Smooth Clamps" provides several clamping functions where the 'floor level' and 'roof level' parameters set the lower and upper limits. These functions are great for limiting any kind of inputs to a specific range.

The script language implicit clamp(fa,0,1) will map to Clamps.linear

• clamp:
  script call : Clamps.linear
  Derived from the Einstein equation of motion that pins any speed addition to the speed of light this clamping function will curve the input so that high input values will converge towards the maximum set by 'roof level'. The 'floor' is set at zero and the smoothing will only affect the continuity near zero. The output is then clearly positive only and in the 0 -B 'roof level' range.
  See the curve with a limit set at 4 in Wolfram Alpha
  The clamp version changes the negative side by using a reflected symmetrical curve to have a perfectly balanced output in y+ and y-. The negative part 'floor' is set to minus 'roof' to keep the curve continuous at zero.
  Einstein clamp gives more natural results for terrains shaping (plateaus filters) as it keeps details on the clamped parts unlike a straight clamp that result in a perfectly flat surface when the input exceeds the clamping range (as seen below).
  
• roof:
  script call : Clamps.roof
  gives more natural results for terrains shaping (plateaus filters) as it keeps details on the clamped parts unlike a straight clamp that result in a perfectly flat surface when the input exceeds the clamping range (as seen below).
  
• floor:
  script call : Clamps.floor
  new comment to add
  
• cubic clamp:
  script call : Clamps.cubic
  comment
  
• Einstein roof:
  script call : Clamps.einsteinroof
  comment
  
• Einstein clamp:
  script call : Clamps.einstein
  comment
  

ArtMatic script function :Contrast

parameters :
A : Contrast amount (-3.0 : 1.0) E9 options
B : Offset (-4.0 : 4.0)

discussion :
A simple, but very useful, contrast filter. When Amount (parameter A), is set to the maximum, there are only two possible output values (i.e. if this is the last component in a system, the result will be a two-tone image). The Offset parameter controls where the contrast divide is made. When used to control picture luminance values, offset effectively adjusts the overall threshold level. See Concentric dither BW for an example.

ArtMatic script function :Discrete_Random

parameters :
A : Amplitude (-100.0 : 100.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 16.0)

discussion :
This component returns a random step function of input x. It is not continuous and not derivable and thus is not advised for ArtMatic Voyager or sound design.

ArtMatic script function :Linear_Random

parameters :
A : Amplitude (-10.0 : 10.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 16.0)

discussion :
A simple discontinuous random function with linear interpolation. Use this component for creating high order harmonics for sound synthesis or when you need sharp edges.

ArtMatic script function :Random

parameters :
A : Amplitude (-10.0 : 10.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 16.0)

discussion :
This component generates a band-limited and continuous random function. Formula : A Random(B(X+C)). Random is simpler and faster than a Perlin Noise.

ArtMatic script function :Periodic_Random

parameters :
A : Amplitude (-16.0 : 16.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 16.0)

discussion :
A periodic (repeating) random function particularly useful for sound applications. It is band-limited and richer than a pure sine wave. The phase parameter adjusts the contour of the random output.

ArtMatic script function :Fractal_noise

parameters :
A : Amplitude (-8.0 : 8.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (-16.0 : 16.0)
D : Roughness (0.300 : 0.600)

discussion :
A 1D version of the fractal noise algorithm. See the descriptions of the higher-dimensional fractal noise components for more information. Besides many graphical applications, Fractal noise can also be used as a sound source to produce 'pink noise" where the amplitude of specific frequencies follow the '1/f' rule. (Unlike 'white noise' which has all frequencies at the same amplitude.). Fractal noise produce a natural and pleasant un-pitched sound. Parameter D, Roughness, controls the fractal dimension. The default 'normal' value is 0.5.

ArtMatic script function :Randomize

parameters :
A : Amount (-10.0 : 10.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 16.0)

discussion :
Randomize displaces input coordinates with a 1D continuous random noise by adding it to the input. 'Amount' controls the displacement amount while 'Frequency' and 'phase' sets the scale and offset of the 1D random noise. This differs from the Random function which generates truly random values.

ArtMatic script function :Slope

parameters :
A : Amplitude (0.0 : 8.0)
B : Offset (-1.0 : 1.0) E9 options

discussion :
This component provides a few algorithms options for calculating the slope of the terrain or 3D field that feeds it. The slope is linked to derivative and a value of zero means the surface is flat. As with the derivative component the 11 slope needs to 'see' the tiles above to evaluate the slope so you can't put it in a compiled tree to evaluate slope of functions located in the main tree.
The 2D Slope modes are meant to be used with 2D systems, while the 3D Slope is meant for volumetric 3D systems.
The mode 3D Slope can be used with 3D terrain to modulate terrain geometry according to the slope of one 3D function. When the Slope is used only for the shading phase when rendering in Voyager use the 13 derivative coming from voyager at no extra cost instead and get the slope by using (1-abs(dy)), dy being the y output of the derivative.

Options:

• 2D Slope normalised:
  Return the normalised slope estimate of the input surface. At 1 the slope would be vertical which practically never occurs for a 2D surface.
• 2D Slope magnitude:
  Return the magnitude of the slope estimate of the input surface. The slope magnitude provides an accurate information of space local scaling and can be connected to depth cuing functions to filter out regions where pixel size becomes infinitely small. Since Slope component can only take a single input use a 21 distance function like Math tools # dist before to measure the space scale when evaluating a 2D space transform.
  The magnitude is computed as length(fx/dt,fy/dt,dt)-1, with dt very small. When 'Offset' parameter is set at 1. the Slope magnitude gives a good approximation of how much a 2D transform scales the space and can be used to generate a S value for DF modeling with 22 complex transforms. See S-Space Scale and 44 S-Space Scale for a discussion on DF S-space technics.
  Example : Libraries/Components demo/DepthCuing by slope.artm
• 3D Slope dy:
  Return the slope estimate of a 3D scalar field. 3D Slope dy can be used with 3D terrain to modulate terrain geometry according to the slope of one 3D function.When the Slope is used only for the shading phase when rendering in Voyager use the 13 derivative coming from voyager at no extra cost instead and get the slope by using (1-abs(dy)), dy being the y output of the derivative.
• 1D Slope df/dx:
  Slope of partial derivative is computed here as length(1.,df/dx )*A + B, 'length' being the euclidian distance function. This option can be used to improve the approximation of distance to a curve when near the roots. The system "Utility Function Plot" "(found in the Structure Presets folder) uses it to calculate a better curve display. The distance estimation is given by (function(x)-y) divided by 1D Slope df/dx.
  Examples : Libraries/Maths/Functions plots/...
• Partial Derivative df/dx: Returns the partial fx/dx derivative value scaled by parameter A : df/dx *A + B; Whatever the dimension of the function above df/dx is the rate of change of the function when x changes.

• White lines:
  script call : Line_shaders.white
  Shades lines in white over black. Equation : Width+1 - contrast *ABS(x). Output is clipped to zero (no negatives).
  
• Black lines:
  script call : Line_shaders.black
  Shades lines in black over white. Equation : Width + contrast *ABS(x). Output is clipped to zero.
  
• DF lines:
  script call : Line_shaders.df
  Uses Width - ABS(x) to output the distance field estimate. Values outside the DF lines are negative.
  
• Neon lines:
  script call : Line_shaders.neon
  Shades lines in white over black with a non linear fallout to simulate a neon effect. Output is clipped to zero.
  
• RGBA lines (Packed):
  script call : Line_shaders.colorpacked
  Shades lines with the color defined procedurally by 'Line color ramp' parameter. Output is RGBA packed and clipped to zero.
  To use packed RGBA Line Shaders modes in RGB without alpha you will need to shade the line using 44 RGB * alpha or a 43 w Multiply. Example : Libraries/Components demo/LineShader Overlay
  
• RGBA fill+ (Packed):
  script call : Line_shaders.colorfill
  Shades the positive side of the line with a RGB color and the other side with the Depth cue color. The color is taken procedurally from the 'Fill Color ramp' parameter.
  
• RGBA fill- (Packed):
  script call : Line_shaders.colorfillneg
  Shades one negative side of the line with a RGB color and the other side with the Depth cue color. The color is taken procedurally from the 'Fill Color ramp' parameter.
  
• RGBA fill & line (Packed):
  script call : Line_shaders.colorfilloutline
  Does both the line and the fill; Negative side are shaded Depth cue color, positive side of the line is shaded with the Fill color and the output alpha is the + side of the line.
  

ArtMatic script function :Compare

parameters :
A : Value (-50.0 : 50.0) E9 options
C : Output Value (0.125 : 64.0)

discussion :
This component provides a way to compare an input value to a single value or value range. Where the input value matches the selection criterion, parameter C's value is passed out. Everywhere else 0 is passed out.

• Equal Exact value:
  True if the input value exactly matches parameter A.
  
• Inside Range:
  True if the input is inside the range bounded by parameter A and parameter A + parameter B.
  
• Outside Range:
  True if the input is outside the range bounded by parameter A and parameter A + parameter B.
  
• Greater than:
  True if the input is greater than parameter A.
  It is equivalent to an abrupt step function. Use the 11 Step component if you need a continuous equivalent.
  
• Less than:
  True if the input is less than parameter A.
  

discussion :
This component serves two functions. It can force a top-level tree to be looped (calculated several times in succession), and it acts as a counter whose value corresponds to the iterations that have been performed. The behavior is slightly different in top-level trees and in compiled trees.

In top-level structure trees, it forces the tree to be looped the number of times specified by parameter B. In compiled trees (and also in top level trees), it returns the number of iterations that have been performed (multiplied by value of the parameter A 'Multiplier'). In sub-trees, the number of iterations to perform is provided by the compiled tree component's Iterations/Recursion parameter.
In general iteration is used in tandem with a "memory" component that will accumulate iterated values along various logic. To perform a mathematical sum just use a simple memory Add. To render a parametric path of a function you can accumulate each point using 11 memory logic minimum connected to a 41 Distance(U,V) component.
(Example of this technic are given in Libraries/Maths/Parametrics and motion/ folder).
In ArtMatic 8 engine a 'Start value' parameter has been added for systems that requires starting at 1. The legacy behavior was the suite started at 0 which still can be achieved by setting the 'Start Value' to zero. During each iteration, this component's output value is: (current iteration number* 'Multiplier' + 'Start value'
Clearly if 'Start value' is 1 and 'Multiplier' is 2 you will get 1, 3, 7, 9,... as output values. With the default parameters values you will simply get the iteration number 1,2,3,4,5,etc. The maximum number of iteration has been set to 256 in ArtMatic Engine 8 (which is the values often used by other iteration tools and Compiled Trees (CTs) ).
Unlike other components "iteration" has no input value and can be seen as a flow control tool.

NOTE: In compiled trees parameter B (iteration numbers) is ignored as the compiled tree component performs the iterations. Examples can be found in Libraries/Textures/Iterative textures

ArtMatic script function :infinity_gate/mask

parameters :
A : Maximum (-1.0 : 256.0) E9 options
B : Minimum (-256.0 : 0.0)

discussion :
This function allows you to create or manage infinities. Infinity has some special characteristics: it is replaced by the Depth cue color in RGB shaded systems) and infinities are treated as transparent in 'packed' mixers and most mathematical operators which provides implicit masking.

• Set infinity in range:
  When the input value is inside the minimum and maximum range 'infinity' is sent out instead
  
• Set infinity out range:
  When the input value is less than the minimum or greater than the maximum the value 'infinity' is sent out instead.
  
• Set infinity below min:
  When the input value is below the threshold 'infinity' is sent out instead.
  
• Set infinity above max:
  When the input value is above the threshold 'infinity' is sent out instead.
  
• Discard infinity:
  Infinities are mapped to parameter A value, thus discarding any infinities (Engine 8.07). In this mode 'Invert Mask' is disabled.
  

• Pass infinity:
  When the input value is less than the minimum or greater than the maximum the value 'infinity' is sent out instead which makes those area transparent in most cases.
  'Invert Mask' can invert the component's effect. When the parameter's value is greater than one, infinity is generated where the input value is between the min and the max parameters.
  
  This is great for creating implicit masking and to optimize calculations in certain areas as most component will simply pass out infinities without computing their normal operations.
• Discard infinity:
  Infinities are mapped to parameter A value, thus discarding any infinities (Engine 8.07). In this mode 'Invert Mask' is disabled.

ArtMatic script function :Memory_Add

parameters :
A : Start Value (-1.0 : 1.0) E9 options
B : Sum Gain (0.0 : 2.0)
C : Auto Gain % (0.0 : 1.0)

discussion :
Memory Add simply adds the new value to the old value. It acts as an accumulator. The 'Start Value' parameter is the initial value which is added to the first iteration. Because the effect accumulates over the iterations, you may sometimes want to set the Start Value to a low value so that the system doesn't attain large/max values everywhere. 'Sum Gain' scales the output. Memory Add is basically a summation tool.
When 'Auto Gain' is set at 1 the weight will be calculated using the context iteration max to keep the sum independent of the iteration number. Lower values will blend with the 'Sum Gain' setting.
Infinities are discarded and treated as transparent.
Recursion formula : memx= x+ memx with 'memx' being the accumulated output value.

discussion :
Memory Fractal Add is another summation tool where the weight of each addition depends on the "power slope" parameter and iteration number. At "power slope" 1 the sum has an equal weight for all iterations. 'power slope' below zero will fade higher iterations while values above zero will fade out the starting iterations. In many fractal systems when iterations scales the frequencies upward the amplitude is scaled inversely. So to maintain this relationship between frequency and amplitude (1/f noises means amplitude is related to inverse frequency) you will typically set the power slope to 0.5 if the frequency is scaled by 2 for example.
The 'Sum Gain' parameter scales the overall output. The start value of the sum is set at zero.
Infinities are discarded and treated as transparent.
Recursion formula : memx= weight*x + memx with weight is set as pow('Power slope', iteration index).

See also the RGBA version at 44 Memory Fractal Add .

• Maximum:
  script call : Memory_Logic.max
  Retains whichever is larger: the new value or the previous value. When the iterations are done, you are this component will essentially have returned the largest value (for each point) of all the iterations.
  
• Minimum:
  script call : Memory_Logic.min
  Retains whichever is smaller: the new value or the previous value. When the iterations are done, you are this component will essentially have returned the smallest value (for each point) of all the iterations.
  
• Xor:
  script call : Memory_Logic.xor
  Logical Xor between incoming values. 2 positives turns negative so the intersection of inputs gets emptied. Zero crossings of both inputs are preserved by Xor when they intersects.
  
• Overlay:
  script call : Memory_Logic.overlay
  Meaningful when values are balanced (negatives as positives) the new values goes over the old. Unlike maximum the zeroes of the new values overlay the older regardless of their values. Negatives are transparent. See the color version examples at 44 Memory w Logic #Overlay
  
• Underlay:
  script call : Memory_Logic.underlay
  Meaningful when values are balanced the new values goes behind the old. Unlike minimum the zeroes of the old values overlay the newer. Negatives are transparent. Underlay and overlay are great to keep the contours of shapes.
  
• Chisel Max:
  script call : Memory_Logic.chmax
  Maximum with a 45° joint where chisel offset parameter sets the joint size.
  
• Chisel Min:
  script call : Memory_Logic.chmin
  Minimum with a 45° joint where chisel offset parameter sets the joint size.
  
• Blend Max:
  script call : Memory_Logic.weighted_max
  Available starting ArtMatic Engine 8.0, this algorithm blends the Max logic with a simple sum. An additional 'blend with sum' parameter controls the blending. It is often useful to keep some details in area where a single max value prevailed.
  
• Blend Min:
  script call : Memory_Logic.weighted_min
  Available starting ArtMatic Engine 8.0, this algorithm blends the Min logic with a simple sum. An additional 'blend with sum' parameter controls the blending.
  

• Difference:
  script call : Memory_Maths.difference
  Uses the absolute difference of iterated inputs with the stored value using the recursion formula : g(x+1)= |x-g(x)|. First iteration is returning the input unchanged. The 'Smoothness' parameter smoothes the edge created by absolute value. "Differences" was the legacy algorithm for this tile.
  
• Multiply:
  script call : Memory_Maths.multiply
  Multiply the input with the stored value. The recursion formula is simply g(x+1)=g(x)*x;
  This may quickly converge towards zero or very high values when the input is far from 1. We recommend to normalise the input values using a clamping function.
  The 'Gain' parameter scales the output and can compensate for diverging series.
  
• Multiply-add:
  script call : Memory_Maths.multiplyadd
  Blends multiplication and addition of inputs using linear interpolation function. The recursion formula is then g(x+1)=mix(g(x)+x,g(x)*x, blend) where the 'Blend' parameter controls the relative weight of * and +.
  
• Morph:
  script call : Memory_Maths.morph
  Accumulates the input values using exponentials. The morph equation is log(exp(x*K)+exp(y*K))/K where K is a smoothing factor. K is derived from the 'Smoothness' parameter. Morph produces a similar result as a smoothed 'Maximum' but with a much smoother and natural blending. You may use it with DF spheres or DF fields to achieve "Metaballs" type of object. A similar functionality is available for RGBA streams with the 44 Memory w Maths # .
  

Legacy components: