OpenVDB
8.1.1

myattribute
and the type float
. The first statement: temp
to be used in the AX program. The second statement: 0.0f
and, if the value is greater than 0.0f
, performs a write to the geometry in the form of float@myattribute = 0.0f;
which sets the value of this attribute on the geometry to 0.0f
. pointgrid
is a single Point Data Grid. For OpenVDB volumes the kernel is run over each voxel in a provided grid: grids
can comprise of any number of OpenVDB volumes. In this program, only a floating point grid with the name myattribute
will be updated. Each voxel in this grid will have it's value compared in the same way as the points example given above.Category  Type  Definition  Attribute Syntax  Points  Voxels 

Scalars  bool  Boolean value, true or false  bool@  Yes  Yes 
int16 *  16bit signed integer value  int16@  Yes  No  
int32  32bit signed integer value  int32@, int@, i@  Yes  Yes  
int  Alias for integer type (typically int32)  
int64  64bit signed integer value  int64@  Yes  Yes  
float  32bit floating point value  float@ f@ @  Yes  Yes  
double  64bit floating point value  double@  Yes  Yes  
Vectors  vec2i  2element vector of integer values  vec2i@  No  No 
vec2f  2element vector of float values  vec2f@  No  No  
vec2d  2element vector of double values  vec2d@  No  No  
vec3i  3element vector of integer values  vec3i@  Yes  Yes  
vec3f  3element vector of float values  vec3f@ v@  Yes  Yes  
vec3d  3element vector of double values  vec3d@  Yes  Yes  
vec4i  4element vector of integer values  vec4i@  No  No  
vec4f  4element vector of float values  vec4f@  No  No  
vec4d  4element vector of double values  vec4d@  No  No  
Matrices  mat3f  3x3matrix of float values  mat3f@  Yes  No 
mat3d  3x3matrix of double values  mat3d@  Yes  No  
mat4f  4x4matrix of float values  mat4f@  Yes  No  
mat4d  4x4matrix of double values  mat4d@  Yes  No  
Strings  string  A string of characters  string@  Yes  Yes 
int
and int32
represent 32bit integer values and int64
represents a 64bit value. float
and double
represent 32bit and 64bit floating point values respectively. All scalars, excluding bools, are signed; there are no other unsigned scalar types in AX. inf
and nan
. These states can occur during invalid floating point arithmetic. AX performs no checks on arithmetic to catch these values. A typical example of both inf
and nan
values are division by zero expressions: vec2i
denotes a vector of two 32bit integer elements. There are no native types for vectors with bool
, int16
or int64
elements, so these are not supported. float
and double
precision elements with dimensions either 3x3
or 4x4
(total size of 9 and 16 elements respectively). There are no integer or boolean matrix types. Similiar to vectors, the suffix letter on the type denotes the contained elements precision, with the number corresponding to the matrix dimension. A matrix of type mat3d
therefor corresponds to a 3x3
matrix (9 elements) with double
precision elements. char
type) have no frontend type, so a string
type must be used for any number of characters (including the empty string). String literals are represented by enclosing any number of supported AX characters by quotes " ".int + float
) values may need to be converted to another type before the operation is performed. To allow for easier writing of expressions, AX will automatically detect these cases and convert values when necessary. This is known as implicit type conversion and the way in which the target operation type is chosen is known as type precedence. mat3f
to mat3d
. The conversion rules for more than the element type (e.g. int
to mat4f
) are governed by AX's assignment and operator rules, detailed in the Operators section of this documentation. vec2i
to vec2f
). Each scalar type has a ranking which is compared, and the resulting highest rank is chosen as the target type for all values. These rankings are defined as follows:double
, all other element types are converted to double
float
, all other element types are converted to float
int64
, all other element types are converted to int64
int32
, all other element types are converted to int32
bool
Operators  

Binary Operators  Unary Operators  Other  
Assignments  Arithmetic  Comparisons / Relational  Logical  Arithmetic  Logical  Increment / Decrement  Container Access  Other 









Operator Name  Operator Syntax  Returns 

Simple assignment  lhs = rhs  Reference to lhs 
Addition assignment  lhs += rhs  Reference to lhs 
Subtraction assignment  lhs = rhs  Reference to lhs 
Multiplication assignment  lhs *= rhs  Reference to lhs 
Division assignment  lhs /= rhs  Reference to lhs 
Modulo assignment  lhs %= rhs  Reference to lhs 
Bitwise AND assignment  lhs &= rhs  Reference to lhs 
Bitwise OR assignment  lhs = rhs  Reference to lhs 
Bitwise XOR assignment  lhs ^= rhs  Reference to lhs 
Bitwise shift left assignment  lhs <<= rhs  Reference to lhs 
Bitwise shift right assignment  lhs >>= rhs  Reference to lhs 
lhs
with a copy of the rhs
: lhs = rhs 
rhs
side is not modified and the lhs
is not read  only written to. If the rhs
type does not match the lhs
type, the rhs
is first implicitly converted into a new temporary with the lhs
type before being copied into the lhs
. The following combination of AX type categories are supported for direct assignment (if an operation is not listed, it is not supported): Left Operand Type  Binary Op(s)  Right Operand Type  Description 

scalar  =  scalar  On type mismatch, right hand side is copied and implicitly cast to the left hand side type. 
vector  =  scalar  Each element of the vector is set to the right hand side scalar. i.e. a[0] = b; ... a[n1] = b; where n is the size of the vector. If the scalar type does not match element type of vector, the scalar is copied and implicitly cast to that type. 
vector  Component wise assignment i.e. a[0] = b; ... a[n1] = b; where n is the size of the vector. vec3f a = 0, b = 1; a = b; vec3f a = 0, b = 1; for (int i = 0; i < 3; ++i) a[i] = b[i];  
matrix  =  scalar  Diagonal matrix construction. Each diagonal component of the left hand side matrix is set to to the right hand side scalar. All other components are zero initialized i.e. mat3f a; int dim = 3, b = 1; for (int i = 0; i < dim; ++i) a[i] = (i % (dim+1) == 0) ? b : 0; a is the matrix, dim is the dimension of the matrix (e.g. 3 for mat3f ) and b is the scalar. If the scalar type does not match element type of matrix, the scalar is copied and implicitly cast to that type. 
matrix  Component wise assignment i.e. a[0] = b[0]; ... a[n1] = b[n1]; where n is the total size of the matrix. mat4f a = 0, b = 1; a = b; mat4f a = 0, b = 1; for (int i = 0; i < 16; ++i) a[i] = b[i];  
string  =  string  Replaces the contents of the left hand side string with a copy of the contents in the right hand side string. 
lhs
with the result of a binary arithmetic operation of the lhs
with the rhs
: lhs op rhs 
+=  =  *=  /=  %=  &=  =  ^=  <<=  >>= 
a += b
) is similar to replacing the compound assignment with a direct assignment followed by a binary expression with the same operands and given arithmetic token (i.e. a = a + b
). However, compound assignments imporantly do not evaluate the lhs
twice. This is important when assigning to an expression which is not an attribute or local value. The best example of this is assigning to a precrement operation: rhs
side is not modified, however the lhs
is both read from and written to. Note that the arithmetic operation may cast either lhs
or rhs
following the rules of AX's arithmetic type precedence. See the arithmetic operations section for more information on arithmetic type precedence and explanations on the above compound operators. a
receives the result of any previous implicit casts to the right hand side of its binary assignment.Operator Name  Operator Syntax  Returns 

Addition  lhs + rhs  The sum of both operands 
Subtraction  lhs  rhs  The first operand minus the second operand 
Multiplication  lhs * rhs  The product of both operands 
Division  lhs / rhs  The first operand divided by the second operand 
Modulo  lhs % rhs  The floored modulo operator. See Multiplicative operands 
Bitwise AND  lhs & rhs  The integral bitwise AND result of each bit in the first operand applied to the bit at the same location in the second operand 
Bitwise OR  lhs  rhs  The integral bitwise OR result of each bit in the first operand applied to the bit at the same location in the second operand 
Bitwise XOR  lhs ^ rhs  The integral bitwise XOR result of each bit in the first operand applied to the bit at the same location in the second operand 
Bitwise shift left  lhs << rhs  The integral bitwise left shift of the first operand by the second operand 
Bitwise shift right  lhs >> rhs  The integral bitwise right shift of the first operand by the second operand 
lhs + rhs 
lhs  rhs 
+
(plus token) is the sum of the operands, and the result of the binary operation with the arithmetic 
(minus token) token is the second operand subtracted from the first operand. The following combination of AX type categories are supported for additive operations (if an operation is not listed, it is not supported): Left Operand Type  Binary Op(s)  Right Operand Type  Description 

scalar  +   scalar  Returns the result of the scalar addition or subtraction. 
vector  Performs per component binary operations (after implicit conversion) with the left hand side scalar to every element of the right hand side vector or matrix, returning a vector or matrix. vec3f a = 2.0f; int b = 1; vec3f c = b + a; vec3f a = 2.0f; int b = 1; vec3f c; for (int i = 0; i < 3; ++i) c[i] = b + a[i];  
matrix  
vector  +   scalar  Same as scalar op vector 
vector  Performs per component binary operations (after implicit conversion), returning a new vector with each element holding the corresponding result. Operand sizes must match. vec3f a = 2, b = 1; vec3f c = a  b; vec3f a = 2, b = 1; vec3f c; for (int i = 0; i < 3; ++i) c[i] = a[i]  b[i];  
matrix  +   scalar  Same as scalar op matrix 
matrix  Performs per component binary operations (after implicit conversion), returning a new matrix with each element holding the corresponding result. Operand sizes must match. mat4f a = 0, b = 1; mat4f c = a  b; mat4f a = 0, b = 1; mat4f c; for (int i = 0; i < 16; ++i) c[i] = a[i]  b[i];  
string  +  string  Performs string concatenation 
a + b = b + a
) but is not necessarily associative. i.e. (a + b) + c
is not necessarily equal to a + (b + c)
. lhs * rhs 
lhs / rhs 
lhs % rhs 
*
(asterisk token) is:/
(forward slash token) is the first operand divided by the second operand.%
(percentage token) is the floored modulo operations .i.e. the expression d % D
returns the result D  d * floor(D/d)
. This is in contrast to truncated modulo operations D  d * (D/d)
where the division is truncated. %
and /
differ when either d
or D
is negative. i.e.: (d/D)*D + (dD) != d
*
has important behaviour for vectors and matrix types. Left Operand Type  Binary Op(s)  Right Operand Type  Description 

scalar  * / %  scalar  Returns the result of the scalar multiplication, division or remainder of the division respectively. 
vector  Performs per component binary operations (after implicit conversion) with the left hand side scalar to every element of the right hand side vector. The scalar is effectively treated as a vector of the same size as the right hand side type. vec3f a = 2.0f; int b = 1; vec3f c = b * a; vec3f a = 2.0f; int b = 1; vec3f c; for (int i = 0; i < 3; ++i) c[i] = b * a[i];  
*  matrix  Performs matrix multiplication after diagonal matrix construction from the left hand side scalar. mat3f a = 1; float b = 1; mat3f c = a * b; mat3f a = 1; float b = 1; mat3f tmp = b; // diagonal matrix mat3f c = a * tmp;  
vector  * / %  scalar  Same as scalar op vector with the operands reversed (importantly for division and modulus) 
vector  Performs per component binary operations (after implicit conversion), returning a new vector with each element holding the corresponding result. Operand sizes must match. vec3f a = 2, b = 1; vec3f c = a * b; vec3f a = 2, b = 1; vec3f c; for (int i = 0; i < 3; ++i) c[i] = a[i] * b[i];  
*  matrix  Transforms the left hand side vector by the right hand side matrix using matrix multiplication. This is the same as calling the transform function. e.g: mat4f a = identity4(); vec3f b = { 1, 2, 3 }; b = b * a; mat4f a = identity4(); vec3f b = { 1, 2, 3 }; b = transform(b, a); mat4 can only be applied to a vec4 . However, it is often useful to be able to directly apply mat4 transformations to vec3 types, most often due to positions being represented as vec3 . vec3 * mat4 multiplication is supported, where by the vec3 is extended with a 1 component and the resulting last last component is dropped from the return value: mat4f a = identity4(); vec3f b = { 1, 2, 3 }; // b * a is equal to: vec4f tmp; tmp[0] = b[0]; tmp[1] = b[1]; tmp[2] = b[2]; tmp[3] = 1; tmp = tmp * a; b[0] = tmp[0]; b[1] = tmp[1]; b[2] = tmp[2];
 
matrix  *  scalar  Same as scalar * matrix 
vector  Transforms the right hand side vector by the left hand side matrix using matrix multiplication. This is the same as calling the pretransform function. e.g: mat4f a = identity4(); vec3f b = { 1, 2, 3 }; b = a * b; mat4f a = identity4(); vec3f b = { 1, 2, 3 }; b = pretransform(a, b); mat4 can only be applied to a vec4 . However, it is often useful to be able to directly apply mat4 transformations to vec3 types, most often due to positions being represented as vec3 . mat4 * vec3 multiplication is supported, where by the vec3 is extended with a 1 component and the resulting last last component is dropped from the return value: mat4f a = identity4(); vec3f b = { 1, 2, 3 }; // a * b is equal to: vec4f tmp; tmp[0] = b[0]; tmp[1] = b[1]; tmp[2] = b[2]; tmp[3] = 1; tmp = a * tmp; b[0] = tmp[0]; b[1] = tmp[1]; b[2] = tmp[2];
 
matrix  Performs matrix multiplication and returns the matrix product, which is matrix of matchign size and type. Operand sizes must match. e.g: mat4f a = 1, b = 2; mat4f c = a * b; mat4f a = 1, b = 2; mat4f c; for(int i = 0; i < 4; ++i) { for(int j = 0; j < 4; ++j) { for(int k = 0; k < 4; ++k) { c[i,j] += a[i,k] * b[k,j]; } } } 
a * b = b * a
) but is not necessarily associative. i.e. (a * b) * c
is not necessarily equal to a * (b * c)
.lhs & rhs 
lhs
 rhs 
lhs ^ rhs 
lhs << rhs 
lhs >> rhs 
&
(ampersand token) is the result of the logical AND operation on each pair of the corresponding bits of the input operands.

(pipe token) is the result of the logical OR operation on each pair of the corresponding bits of the input operands.^
(hat token) is the result of the logical XOR operation on each pair of the corresponding bits of the input operands.<<
(less than tokens) is the value shifted left with zeros shifted in on the right.>>
(greater than tokens) is the value shifted right with zeros shifted in on the left. bool
. Binary comparison operations have the following forms: Operator Name  Operator Syntax  Returns 

Equal to  lhs == rhs  Returns true if both operands are equal 
Not equal to  lhs != rhs  Returns true if operands are not equal 
Less than  lhs < rhs  Returns true the left hand side value is less than the right hand side 
Greater than  lhs > rhs  Returns true the left hand side value is greater than the right hand side 
Less than or equal to  lhs <= rhs  Returns true the left hand side value is less than or equal to the right hand side 
Greater than or equal to  lhs >= rhs  Returns true the left hand side value is greater than or equal to the right hand side 
Left Operand Type  Binary Op(s)  Right Operand Type  Description 

scalar  == != < > <= >=  scalar  Returns the result of the scalar comparison. 
vector  Performs per component comparisons (after implicit conversion) with the lefthand side scalar to every element of the right hand side vector or matrix and perform a logical AND combination on the results of these comparisons. This effectively returns true if every element of the vector or matrix is equal to the scalar. vec3f a = 2.0f; int b = 1; bool c = b == a; vec3f a = 2.0f; int b = 1; bool c = a[0] == b; for (int i = 1; i < 3; ++i) c &= a[i] == b;  
matrix  
vector  == != < > <= >=  scalar  Same as scalar op vector 
vector  Performs binary comparison operations (after implicit conversion) on each pair corresponding components in the vector operands and returns true if all component pairs are equal. Operand sizes must match. vec3f a = 1, b = 2; bool c = a == b; vec3f a = 1, b = 2; bool c = a[0] == b[0]; for (int i = 1; i < 3; ++i) c &= a[i] == b[i];  
matrix  == != < > <= >=  scalar  Same as scalar op matrix 
matrix  Performs binary comparison operations (after implicit conversion) on each pair corresponding components in the matrix operands and returns true if all component pairs are equal. Operand sizes must match. mat4f a = 1, b = 2; bool c = a == b; mat4f a = 1, b = 2; bool c = a[0] == b[0]; for (int i = 1; i < 16; ++i) c &= a[i] == b[i]; 
bool
types if they are not already. Operator Name  Operator Syntax  Returns 

AND  lhs && rhs  Returns true if both operands are true. Otherwise, the result is false. This operator is shortcircuiting. 
Inclusive OR  lhs  rhs  Returns true if either the first or the second operand is true. This operator is shortcircuiting. 
Operator Name  Operator Syntax  Returns 

Unary plus  + a  Returns the value of its operand, a 
Unary minus   a  Returns the negative representation of a 
Bitwise NOT  ~ a  Returns the bitwise NOT (one's complement) value of a . This operator is only valid on integral element types. 
Operand Type  Binary Op(s)  Description 

scalar  +  ~  Returns the result of the scalar unary operations. 
vector  Performs per component unary operations, returning a new vector with each element holding the corresponding result. Operand sizes must match. vec3f a = 2; vec3f b = a; vec3f a = 2; vec3f b; for (int i = 0; i < 3; ++i) b[i] = a[i]; ~ operator is only valid on integer vector types; vec2i , vec3i and vec4i .  
matrix  +   Performs per component unary operations, returning a new matrix with each element holding the corresponding result. Operand sizes must match. vec3f a = 2; vec3f b = a; vec3f a = 2; vec3f b; for (int i = 0; i < 3; ++i) b[i] = a[i]; 
Operator Name  Operator Syntax  Returns 

Logical NOT  ! a  Returns true if the operand is false. Otherwise, returns false. 
Operand Type  Binary Op(s)  Description 

scalar  !  Returns the result of the scalar logical operation. The scalar operand is converted to a bool if it is not already. 
vector  Performs per component unary operations, returning a new vector with each element holding the corresponding result. Operand sizes must match. vec3i a = 2; vec3i b = !a; vec3i a = 2; vec3i b; for (int i = 0; i < 3; ++i) b[i] = !a[i]; ! operator is only valid on integer vector types; vec2i , vec3i and vec4i . 
Operator Name  Operator Syntax  Returns 

Preincrement  ++ a  Returns a reference to the incremented result. 
Postincrement  a ++  Returns a copy of the incremented result. 
Predecrement   a  Returns a reference to the decremented result. 
Postdecrement  a   Returns a copy of the decremented result. 
Operand Type  Binary Op(s)  Description 

scalar  ++(pre) (post)++ (pre) (post)  Returns the result (reference or copy) of the scalar increment or decrement operation. Note: boolean incrementation and decrementation is not supported. Only int32 , int64 , float and double types are valid. 
Operator Name  Operator Syntax  Returns 

Dot Component Access  vector . component  Reference to component component of vector 
Container Component Access  container [ exp ]  Reference to component at index exp of container 
Matrix Component Access  matrix [ exp1 , exp2 ]  Reference to component in row exp1 , column exp2 . Also equal to returning a reference to component at index:
[exp1 * dimension + exp2] of matrix where dimension is the the size of the matrix 
[]
operator is valid for both types. However the . operator is only valid on vector types, and the [,]
operator is only valid on matrix types. As return values for these operators are references, any modifications through assignments will update the stored value in the container. vector . component 
vec2
types, only the first 2 components are accessible). Accessing a vector using the dot operator is fundamentally the same as using the
[]
operator with the corresponding integer index.
Component  Access Index  Result 

A.x  0  
A.r  0  
A.y  1  
A.g  1  
A.z  2  
A.b  2 
[]
operator is valid for both vectors and matrices. It has the form: container [ exp ] 
exp
is expected to evaluate to a value which is castable to an integer following the assignment casting rules and falls within the valid size of the container
. No bounds checking is performed.
[,]
operator is only valid for matrices. It has the form: matrix [ exp1 , exp2 ] 
exp1
and exp2
are expected to evaluate to a value which is castable to an integer following the assignment casting rules and falls within the valid size of the matrix
dimensions. No bounds checking is performed. In general it is more readable to use this operator when accessing specific elements, where exp1
is the row index and exp2
is the column index. The tables below show the different access patterns for 3x3
and 4x4
matrices.

 
Access [a]  Access [a,b]  Result  Access [a]  Access [a,b]  Result  

A[0]  A[0,0]  A[0]  A[0,0]  
A[1]  A[0,1]  A[1]  A[0,1]  
A[2]  A[0,2]  A[2]  A[0,2]  
A[3]  A[1,0]  A[3]  A[0,3]  
A[4]  A[1,1]  A[4]  A[1,0]  
A[5]  A[1,2]  A[5]  A[1,1]  
A[6]  A[2,0]  A[6]  A[1,2]  
A[7]  A[2,1]  A[7]  A[1,3]  
A[8]  A[2,2]  A[8]  A[2,0]  
A[9]  A[2,1]  
A[10]  A[2,2]  
A[11]  A[2,3]  
A[12]  A[3,0]  
A[13]  A[3,1]  
A[14]  A[3,2]  
A[15]  A[3,3] 
Operator Name  Operator Syntax  Returns 

Call / Explicit Cast  a
(...)  Returns the result of a function call or inbuilt explicit cast 
Comma  a , b  Returns the value of b after chained evaluation 
Ternary Conditional  a
? b
: c  b if a is true, c otherwise. 
Vector/Matrix Initializer  { a , b
... }  Returns a temporary vector or matrix 
func ( a , b , c ...) 
func
is a function name or a valid explicit cast typename. Explicit casts are only supported for scalar types. For example: a
, b 
a
and b
are expressions. Chained expressions evaluate each expression in syntactical order (first to last), discarding any return value except for the last expression, which is returned from the entire list. Note that although return values for any expression but the last are discarded, their side effects are still applied before subsequent expression are evaluated. For example: a
? b
: c 
a
is the condition, evaluated and converted to bool, and b
and c
are expressions of the same or implicitcastable types. b
is evaluated and returned if the condition is true, c
is evaluated and returned if the condition is false. Only the expression out of b
and c
that is returned will be evaluated. Expressions with no return value (a.k.a void
) are supported as long as b
and c
are both of this type. a
?
:
c
(or ?:
). Here, a
is evaluated once, and if when converted to bool is true, a
is returned, otherwise c
is evaluated and returned. In this case, a
and c
must be the same or implicitcastable types, and both implicitcastable to bool.vec3f
), external attributes or parameters (e.g. vec3f@attrib
) or as temporary values using the vector/matrix initializer syntax. This operator has the form: { a , b
... } 
a
and b
are expressions returning a scalar value. When this operator is invoked with a specific number of arguments, a vector or matrix is implicitly created with a copy of those arguments which can be assigned to an existing container of matching size. Expression in the operator are evaluated from first to last. This operator is only valid with argument lists of sizes 2, 3, 4, 9 and 16, which implicitly represent vec2, vec3, vec4, mat3, and mat4 types respectively. For example: a
[0]
is copied into the initializer operator. mat3d
, before being implicitly cast to a mat3f
due to the assignment.Precedence  Operator  Description  Associativity 

1  ()  Parenthesis  Lefttoright 
2  a++ a  Suffix/postfix Increment / Decrement  
type()  Functional cast  
a()  Function call  
a[] .  Container Access  
3  ++a a  Prefix Increment / Decrement  Righttoleft 
+a a  Unary plus and minus  
! ~  Logical NOT and Logical NOT  
4  a*b a/b ab  Multiplication, division, and remainder  Lefttoright 
5  a+b a−b  Addition and subtraction  
6  << >>  Bitwise left shift and right shift  
7  < <=  For Comparisons / Relational operators < and ≤ respectively  
> >=  For Comparisons / Relational operators > and ≥ respectively  
8  == !=  For Comparisons / Relational operators = and ≠ respectively  
9  &  Arithmetic AND  
10  ^  Arithmetic XOR (exclusive or)  
11    Arithmetic OR (inclusive or)  
12  &&  Logical AND  
13    Logical OR  
14  a?b:c  Ternary operator  Righttoleft 
=  Direct assignment  
+= =  Compound assignment by sum and difference  
*= /= %=  Compound assignment by product, quotient, and remainder  
<<= >>=  Compound assignment by bitwise left shift and right shift  
&= ^= =  Compound assignment by bitwise AND, XOR, and OR  
15  ,  Comma  Lefttoright 
a = b = c
is parsed as a = (b = c)
, and not as (a = b) = c
because of righttoleft associativity of assignment, but a + b − c
is parsed (a + b) − c
and not a + (b − c)
because of lefttoright associativity of addition and subtraction. Note that this is based off the C++ operator precedence.Type  Literal Tokens 

bool  Tokens true and false 
int32  No suffix, automatically infered from integral literals 
int64  The letter l e.g.int64 a = 10l; 
float  The letter f e.g.float a = 0.0f; 
double  No suffix, automatically infered from floating point literals. 
string  Character strings wrapped in double quotes " " 