// comment
/* comment */

// this is a comment

/* this is a
   multi-line
   comment
*/

dataType

number

boolean

'string'

"string"

1

1.5

1.0e30

true

'some string'

"some string"

@level

@10

@levels

@10

@(finest - 1)

(base + offset)

(base - offset)

(finest - 1)

alias

@all

(
  levels
  /* optional */ but exclude
  )

(0, 2, 4)

(all but finest)

( begin to end )

(coarsest to finest)

/* optional */ noinline
  Function name
  /* optional */ levels
  /* optional */ ( arguments )
  /* optional */ : returnType
  { body }

Function F ( xPos : Real, yPos : Real ) : Real {
  return sin ( xPos ) * cos ( yPos )
}

Function Smoother@all {
  /* ... */
}

name : dataType

someParam : Real

return
  /* optional */ returnValue

return

return sin ( xPos ) * cos ( yPos )

name
  /* optional */ levels
  /* optional */ offset
  ( parameters )

Var res : Real = F ( 0.5, 0.5 )

Smoother@current ( )

Var name : dataType
  /* optional */ levels
  /* optional */ = initial

Var cnt : Int = 0
Var curError : Real = 0

Val name : dataType
  /* optional */ levels
  = initial

Val maxNumIts : Int = 128
Val a : Real = 10.5 * 4.

dest = src

Var cnt : Int
cnt = 0

dest += src

dest -= src

dest *= src

dest /= src

Var cnt : Int = 0
cnt += 1

op target

-1

!true

left op right

1 + 2

MyStencil * MyField

repeat n times
  /* optional */ count variable
  { body }

Var cnt : Int = 0
repeat 10 times count cnt {
  print ( 'Iteration', cnt )
}

 repeat until condition { body } 

 repeat while condition { body } 

Var cnt : Int = 0
repeat until 10 == cnt {
  print ( 'Iteration', cnt )
  cnt += 1
}

if ( condition ) { ifBranch }
  /* optional */ else elseBranch

if ( true ) {
  print ( 'always true' )
} else {
  print ( 'will not be evaluated' )
}

Var someVar : Real = 0.5
if ( 0. == someVar or 1. == someVar ) {
  // ...
}

[ i_0 ]

[ i_0 , i_1 ]

[ i_0 , i_1 , i_2 ]

[ 1, 0 ]

[ 0, 1, -1 ]

[ e_0 ]

[ e_0 , e_1 ]

[ e_0 , e_1 , e_2 ]

[ 0, 1, -1 ]

[ ( i0 % 2 ), ( i1 % 2 ) ]

Domain name < lower to upper >

Domain unitSquare < [0., 0.] to [1., 1.] >

Domain global < [0, 0, 0] to [2, 4, 6] >

Layout name < dataType , localization > 
  /* optional */ levels
  { options }

Layout CellLayout < Real , Cell > @all {
  duplicateLayers = [ 0, 0, 0 ]
  ghostLayers     = [ 1, 1, 1 ] with communication
}

option = index
  /* optional */ with communication

Field name < domain , layout , boundaryCondition >
  /* optional */ [ numSlots ]
  /* optional */ levels

Field vis < global, CellLayout, None >

Field rho < global, CellLayout, Neumann > [2] @all

None

Neumann
  /* optional */ ( order )

dirichlet

bcFunction ( )

Neumann ( 1 )

sin ( vf_boundaryPosition_x )

applyBoundaries ( )

external Field name < layout > => internal

Layout CellLayout < Real , Cell > { /* ... */ }
Layout ExternalLayout < Real , Cell > @finest { /* ... */ }

Field p < global, CellLayout, Neumann >

external Field p_0 < ExternalLayout > => p@finest

Stencil name
  /* optional */ levels
  { entries }

Stencil FivePoint@all {
  [ 0,  0] =>  4.0
  [-1,  0] => -1.0
  [ 1,  0] => -1.0
  [ 0, -1] => -1.0
  [ 0,  1] => -1.0
}

Stencil RestrictCell {
  [i0, i1] from [ 2 * i0,     2 * i1     ] with 0.25
  [i0, i1] from [ 2 * i0,     2 * i1 + 1 ] with 0.25
  [i0, i1] from [ 2 * i0 + 1, 2 * i1     ] with 0.25
  [i0, i1] from [ 2 * i0 + 1, 2 * i1 + 1 ] with 0.25
}

offset => coefficient

[ 0,  0] =>  4.0 * alpha + epsilon

row from col with coefficient

[i0, i1] from [ 2 * i0, 2 * i1 ] with 1.0

Stencil name
  /* optional */ levels
  from expression

Stencil Horizontal { /* ... */ }
Stencil Vertical   { /* ... */ }
Stencil Combined from 2.0 * ( Horizontal + Vertical )

Stencil name
  /* optional */ levels
  from default operation on localization with parameter

RestrictNode from default restriction on Node with 'linear'

StencilField name < field => stencil >
  /* optional */ levels

Layout SfLayout < Vector < Real, 5 > , Cell > { /* ... */ }
Field StencilData < global, SfLayout, None >

Stencil FivePointShape { /* ... */ }

StencilField StoredFivePoint < StencilData => FivePointShape >

target
  /* optional */ [ slot ]
  /* optional */ @ level
  /* optional */ @ offet
  /* optional */ : direction
  /* optional */ [ component ]

someVar

someField[active]@current@[1, 0]

someStencil@current:[0, 0]

someStencilField@[1, 0]:[0, 0]

loop over field
  /* optional */ only region
  /* optional */ sequentially
  /* optional */ where condition
  /* optional */ starting offsetBegin
  /* optional */ ending offsetEnd
  /* optional */ stepping stepSize
  /* optional */ with reduction
  /* optional */ preComm
  /* optional */ postComm
  { body }

loop over u { /* ... */ }

loop over u where 0 == ( i0 + i1 ) % 2 { /* ... */ }

loop over u only ghost [0, -1] on boundary { /* ... */ }

loop over u starting [1, 0] stepping [2, 1] { /* ... */ }

Var curErr : Real = 0.0
loop over u with reduction ( max, curErr ) { /* ... */ }

target direction
  /* optional */ on boundary

only dup [0, -1] on boundary

loop over fragments
  /* optional */ with reduction
  { body }

Var sum : Real = 0.0
loop over fragments with reduction ( + : sum ) {
  loop over u with reduction ( + : sum ) { /* ... */ }
}

reduction ( op : target )

Var sum : Real = 0.0
loop over u with reduction ( + : sum ) { /* ... */ }

repeat n times
  /* optional */ count variable
  with contraction posExtent
  /* optional */ , negExtent
  { body }

// 2D example

loop over fragments {
  /* contraction: iterate over 
    [0-(5-1)*1, 0] to [32+(5-1)*1, 32]
    [0-(5-2)*1, 0] to [32+(5-2)*1, 32]
    ...
    [0, 0] to [32, 32]
  */
  repeat 5 times with contraction [1, 0 ] {
    // regular: iterate over [0, 0] to [32, 32]
    loop over Solution@finest {
      // ...
    }
  }

  /* contraction: iterate over 
    [0-(3-1)*(-2), 0] to [32+(3-1)*1, 32], 
    [0-(3-2)*(-2), 0] to [32+(3-2)*1, 32],
    [0, 0] to [32, 32]
  */
  repeat 3 times with contraction [1, 0 ], [-2, 0] {
    // regular: iterate over [0, 0] to [32, 32]
    loop over Solution@finest {
      // ...
    }
  }
}

/* optional */ begin
  /* optional */ finish
  communicate targets of field
  /* optional */ where condition

communicate u[next]@current

begin communicating u
/* ... */
finish communicating u

target
  /* optional */ start 
  /* optional */ to end // inclusive indices

examples of usage

preComm
  /* optional */ op
  target  
  of field
  /* optional */ where condition

postComm
  /* optional */ op
  target  
  of field
  /* optional */ where condition

precomm all of Solution@current

postcomm dup of Solution where 0 == ( i0 + i1 ) % 2

apply bc to field

apply bc to u

i0

i1

i2

0 == ( i0 + i1 + i2 ) % 2

target

advance field

advance u

solve locally
  /* optional */ with jacobi
  /* optional */ relax omega
  { components }

loop over u {
  solve locally relax 0.8 {
    u@[0, 0] => laplace@[0, 0] * u@[0, 0] == rhs_u@[0, 0]
    u@[1, 0] => laplace@[1, 0] * u@[1, 0] == rhs_u@[1, 0]
  }
}

unknown => lhs == rhs

u => laplace * u == 0.0

u@[1, 0] => laplace@[1, 0] * u@[1, 0] == rhs_u@[1, 0]

repeat with { conditions , body }

repeat with {
  ( 0 == ( i0 + i1 ) % 2 ),
  ( 1 == ( i0 + i1 ) % 2 ),
  
  loop over p { /* ... */ }
  communicate p
}

color with { colors , body }

color with {
  i0 % 2,
  i1 % 2,
  
  loop over p { /* ... */ }
  communicate p
}

import filename

import '../lib/defaultGlobals.exa4'

Knowledge { parameters }

Knowledge {
  opt_useAddressPrecalc = true
  opt_unroll            = 2
}

Globals { entries }

Globals {
  Var omega     : Real = 0.8
  Val maxNumIts : Int  = 128
}

FunctionTemplate name < templateParams > ( functionParams ) : returnType { body }

FunctionTemplate SetFieldComponent < target > ( value : Real ) : Unit {
  loop over target {
    target = value
  }
}

Instantiate template < templateArgs > as name
  /* optional */ levels

Instantiate SetFieldComponent < u@current > as SetSolution_u@all
Instantiate SetFieldComponent < v@current > as SetSolution_v@all

levels { body }

Function recursive@all () {
  /* ... */

  @(all but coarsest) {
    recursive@coarser ( )
  }
}

{expression, expression, ...  } /* optional */ T

Var v1 : Vector<Real, 3> = { 1, 2, 3}
Var v2 : Vec3 = [1 2 3] + [4 5 6]
Var v3 : ColumnVector<Int, 3> = {1, 2, 3}T

{{expression, expression, ...  }, {expression, expression, ...  }, ... }

Var m1 : Matrix<Real, 2, 2> = {{1, 2}, {3, 4}}
Var m2 : Matrix<Real, 2, 3> = [1 2 3; 4 5 6]

Var quadMat : Matrix <Real, 2, 23> = {{0., 1.}, {1., 0.}}
Var colVecMat : Matrix <Real, 3, 13> = {{0.}, {1.}, {1337.}}
Var rowVec : RowVector <Real, 33> = {0., 1., 1337.}

quadMat[0][1] = 3
Var tmp : Real = colVecMat[0]
rowVec[1] = 1

setSlice(quadMat,0,1,2,1,5) // quadMat = {{0., 1.}, {5., 5.}}
Var row : Matrix<Real, 1, 2 > = getSlice(quadMat,0,1,1,2) // row = {{5., 5.}}
Var col : Matrix<Real, 2, 1 > = quadMat[:][1] // col = {{1.},{5.}}
rowVec[0:3] = 4. // colVec = {{4.},{4.},{4.}}

Var A : Matrix<Real, 3, 3> = {{3,2,-1},{2,-2,4},{-1,0.5,-1}}
Var f : Matrix<Real, 3, 1> = {{1},{-2},{0}}
Var u : Matrix<Real, 3, 1>
solveMatSys A,u,f // u = {{1}, {-2}, {-2}}

solveMatSys A2,u2,f2 {shape=blockdiagonal,block=3} // A2 is a blockdiagonal matrix with blocks of size 3x3

Var mat_inverse : Matrix<Real, 7, 7> = inverse(mat, "shape=schur", "block=6", "A=blockdiagonal", "Ablock=3")