VEX includes an array datatype. This is useful in several places:

• Supporting ramp parameters.

• Reading capture data from surface nodes using the import() function.

• General programming, wherever arrays would be useful.

This example shows off some of the crazy things that you can do with arrays:

surface
crazy(
      string maps[] = { "Mandril.rat", "default.pic" };
      export float alength = 0;
      )
{
    vector texclr, av[];

    texclr = texture(maps[s+t > 1], s, t);
    av = array( {1,0,0}, vector(nrandom()), t, texclr, {.5,0,0});

    if (fit(noise(s*8), 0, 1, .3, .7) > t)
        av = array(1, {0,1,0}, 0);

    Cf = spline("linear", s, av);
    alength = len(av);
}

To declare an array variable, the general form is member_type var_name[]:

// my_array is an array of floats
float   my_array[];

// v is a single vector, vector_array is an array of vectors
vector  v, vector_array[];

// str_array is an array of strings
string  str_array[];

You can optionally put a size inside the square brackets, but the VEX compiler currently ignores it.

To declare a function that returns an array:

// A function which returns an array of vectors
// DOES NOT WORK IN A WRANGLE/SNIPPET: use function keyword then.
vector[] rgb_array()
{
...
};    

It is ambiguous if you are a nested function, however. Note that Wrangles and Snippets are always implicitly nested. To declare a nested function that returns an array:

// A function which returns an array of vectors
cvex
foo()
{
    // Use the optional 'function' keyword to avoid type ambiguity
    function vector[] rgb_array()
    {
    ...
    };    
}

To specify a literal array, use curly braces, with the array members separated by commas:

vector an_array[] = { {1, 2, 3}, {2, 3, 4}, {4, 5, 6} };

vector[] rgb_array()
{
    return { {1, 0, 0}, {0, 1, 0}, {0, 0, 1} };
}

int arr[] = { my_var, other_var + 2 }; // Error

int arr[] = array( my_var, other_var + 2 );

If you specify scalars where a vector is expected, the compiler assigns the scalar value to all components of the vector:

vector an_array[] = { 1, 2, 3};
// an_array[] == { {1, 1, 1}, {2, 2, 2}, {3, 3, 3} }

The array() function creates an array from its arguments.

int my_array[] = array(1, 2, 3, 4, 5);

You can use array() to generate an array of any type. To force array() to generate vectors (for example):

vector (array (value1, value2, ...) );

Use arrayname[index] to look up a value by its position in the array.

vector bw[] = { 0, 1 };
// bw[] == { {0, 0, 0}, {1, 1, 1} }
Cf = bw[index];

Array bounds are checked at run time. Reading out of bounds will return 0 or "". This may generate a warning or optional run-time error in the future. Writing past the end of an array will resize the array to include the index written to. The new entries will be set to 0 or "".

Python-style indexing is used. This means negative indices refer to positions from the end of the array.

int nums[] = { 0, 1, 2, 3, 4, 5 };
int n = nums[10];  // Returns 0
int b = nums[-2];  // Returns 4

string strs[] = { };
string s = strs[20];  // Returns ""

You can also assign values using the square brackets notation:

float nums[] = { };
nums[0] = 3.14;

(The getcomp and setcomp functions are equivalents for using the square brackets notation.)

The square-brackets can be used to extract sub-arrays using the Python slicing notation.

int nums[] = { 0, 1, 2, 3, 4, 5 };
int start[] = nums[0:2];  // { 0, 1 }
int end[] = nums[-2:];  // { 4, 5 }
int rev[] = nums[::-1];  // { 5, 4, 3, 2, 1, 0 }
int odd[] = nums[1::2]; // { 1, 3, 5 }

The slice function is the equivalent for using the slice-based square brackets notation.

The assignment operator supports assigning values between vector types and arrays of floats:

float x[];
// Cf and P are vectors

x = set(P);   // Assigns the components of P to the corresponding
              // members of the array x

Cf = set(x);  // Assigns the first 3 members of x as the
              // components of the vector Cf

If the array is not long enough to fill the vector/matrix, the last member is repeated as often as necessary.

float x[] = {1, 2} // Not long enough to fill a vector
Cf = set(x);  // Cf == {1, 2, 2}

You can also assign between matrix types and arrays of vector2/vector/vector4:

vector2     v2[];
vector      v[];
vector4     v4[];
matrix2     m2 = 1;
matrix3     m3 = 1;
matrix      m4 = 1;

v = set(m3);   // Each row of the 3x3 matrix is put into a vector
m3 = set(v);   // Copy the vectors into the row vectors of the matrix
v4 = set(m4);  // Extract the rows of the matrix into the vector4 array
m4 = set(v4);  // Create a matrix using the vector4's in the array as row vectors

In summary:

See foreach.

The following functions let you query and manipulate arrays.

In addition, the following functions work with arrays:

• min

• avg

• spline

• import()

• addattribute()

• metaimport

The ramp pragma lets you specify a ramp user interface for a set of parameters.

#pragma ramp <ramp_parm> <basis_parm> <keys_parm> <values_parm>

See VCC pragmas for more information.

• Currently VEX does not support multi-dimensional arrays.

• Arrays cannot be passed between shaders (through simport, etc.).

• Arrays cannot be written to image planes.