Operators

This file is automatically generated from java files. Do Not Edit It.

Definition

Operators in the GAML language are used to compose complex expressions. An operator performs a function on one, two, or n operands (which are other expressions and thus may be themselves composed of operators) and returns the result of this function.

Most of them use a classical prefixed functional syntax (i.e. operator_name(operand1, operand2, operand3), see below), with the exception of arithmetic (e.g. +, /), logical (and, or), comparison (e.g. >, <), access (., [..]) and pair (::) operators, which require an infixed notation (i.e. operand1 operator_symbol operand1).

The ternary functional if-else operator, ? :, uses a special infixed syntax composed with two symbols (e.g. operand1 ? operand2 : operand3). Two unary operators (- and !) use a traditional prefixed syntax that does not require parentheses unless the operand is itself a complex expression (e.g. ` - 10, ! (operand1 or operand2)`).

Finally, special constructor operators ({...} for constructing points, [...] for constructing lists and maps) will require their operands to be placed between their two symbols (e.g. {1,2,3}, [operand1, operand2, ..., operandn] or [key1::value1, key2::value2... keyn::valuen]).

With the exception of these special cases above, the following rules apply to the syntax of operators:

if they only have one operand, the functional prefixed syntax is mandatory (e.g. operator_name(operand1))
if they have two arguments, either the functional prefixed syntax (e.g. operator_name(operand1, operand2)) or the infixed syntax (e.g. operand1 operator_name operand2) can be used.
if they have more than two arguments, either the functional prefixed syntax (e.g. operator_name(operand1, operand2, ..., operand)) or a special infixed syntax with the first operand on the left-hand side of the operator name (e.g. operand1 operator_name(operand2, ..., operand)) can be used.

All of these alternative syntaxes are completely equivalent.

Operators in GAML are purely functional, i.e. they are guaranteed to not have any side effects on their operands. For instance, the shuffle operator, which randomizes the positions of elements in a list, does not modify its list operand but returns a new shuffled list.

Priority between operators

The priority of operators determines, in the case of complex expressions composed of several operators, which one(s) will be evaluated first.

GAML follows in general the traditional priorities attributed to arithmetic, boolean, comparison operators, with some twists. Namely:

the constructor operators, like ::, used to compose pairs of operands, have the lowest priority of all operators (e.g. a > b :: b > c will return a pair of boolean values, which means that the two comparisons are evaluated before the operator applies. Similarly, [a > 10, b > 5] will return a list of boolean values.
it is followed by the ?: operator, the functional if-else (e.g. ` a > b ? a + 10 : a - 10` will return the result of the if-else).
next are the logical operators, and and or (e.g. a > b or b > c will return the value of the test)
next are the comparison operators (i.e. >, <, <=, >=, =, !=)
next the arithmetic operators in their logical order (multiplicative operators have a higher priority than additive operators)
next the unary operators - and !
next the access operators . and [] (e.g. {1,2,3}.x > 20 + {4,5,6}.y will return the result of the comparison between the x and y ordinates of the two points)
and finally the functional operators, which have the highest priority of all.

Using actions as operators

Actions defined in species can be used as operators, provided they are called on the correct agent. The syntax is that of normal functional operators, but the agent that will perform the action must be added as the first operand.

For instance, if the following species is defined:

species spec1 {
        int min(int x, int y) {
                return x > y ? x : y;
        }
}

Any agent instance of spec1 can use min as an operator (if the action conflicts with an existing operator, a warning will be emitted). For instance, in the same model, the following line is perfectly acceptable:

global {
        init {
                create spec1;
                spec1 my_agent <- spec1[0];
                int the_min <- my_agent min(10,20); // or min(my_agent, 10, 20);
        }
}

If the action doesn’t have any operands, the syntax to use is my_agent the_action(). Finally, if it does not return a value, it might still be used but is considering as returning a value of type unknown (e.g. unknown result <- my_agent the_action(op1, op2);).

Note that due to the fact that actions are written by modelers, the general functional contract is not respected in that case: actions might perfectly have side effects on their operands (including the agent).

Operators by categories

Dates

Driving operators

as_driving_graph,

edge

edge_between,

diff, diff2, internal_zero_order_equation,

crs, file, file_exists, folder, get, new_folder, osm_file, read, writable,

conversation, message,

add_edge, add_node, adjacency, agent_from_geometry, all_pairs_shortest_path, alpha_index, as_distance_graph, as_edge_graph, as_intersection_graph, as_path, beta_index, betweenness_centrality, biggest_cliques_of, connected_components_of, connectivity_index, contains_edge, contains_vertex, degree_of, directed, edge, edge_between, edge_betweenness, edges, gamma_index, generate_barabasi_albert, generate_complete_graph, generate_watts_strogatz, grid_cells_to_graph, in_degree_of, in_edges_of, layout, load_graph_from_file, load_shortest_paths, maximal_cliques_of, nb_cycles, neighbors_of, node, nodes, out_degree_of, out_edges_of, path_between, paths_between, predecessors_of, remove_node_from, rewire_n, source_of, spatial_graph, successors_of, sum, target_of, undirected, use_cache, weight_of, with_optimizer_type, with_weights,

as_4_grid, as_grid, as_hexagonal_grid, grid_at, path_between,

Iterator operators

accumulate, as_map, collect, count, distribution_of, distribution_of, distribution_of, distribution2d_of, distribution2d_of, distribution2d_of, first_with, frequency_of, group_by, index_by, last_with, max_of, mean_of, min_of, product_of, sort_by, sum_of, variance_of, where, with_max_of, with_min_of,

copy_between, index_of, last_index_of,

Logical operators

:, !, ?, and, or,

Map comparaison operators

fuzzy_kappa, fuzzy_kappa_sim, kappa, kappa_sim, percent_absolute_deviation,

as_map, index_of, last_index_of,

Material

material,

-, /, ., [](#), +, append_horizontally, append_vertically, column_at, columns_list, determinant, eigenvalues, index_of, inverse, last_index_of, row_at, rows_list, shuffle, trace, transpose,

multicriteria operators

electre_DM, evidence_theory_DM, promethee_DM, weighted_means_DM,

agent_from_geometry, all_pairs_shortest_path, as_path, load_shortest_paths, path_between, path_to, paths_between, use_cache,

-, /, [](#), +, <, <=, >, >=, add_point, angle_between, any_location_in, centroid, closest_points_with, farthest_point_to, grid_at, norm, point, points_along, points_at, points_on,

Random operators

binomial, flip, gauss, poisson, rnd, rnd_choice, sample, shuffle, skew_gauss, truncated_gauss,

ReverseOperators

Shape

arc, box, circle, cone, cone3D, cross, cube, curve, cylinder, ellipse, envelope, geometry_collection, hexagon, line, link, plan, polygon, polyhedron, pyramid, rectangle, sphere, square, squircle, teapot, triangle,

Spatial operators

-, [](#), +, add_point, agent_closest_to, agent_farthest_to, agents_at_distance, agents_inside, agents_overlapping, angle_between, any_location_in, arc, around, as_4_grid, as_grid, as_hexagonal_grid, at_distance, at_location, box, centroid, circle, clean, closest_points_with, closest_to, cone, cone3D, convex_hull, covers, cross, crosses, crs, CRS_transform, cube, curve, cylinder, dem, direction_between, disjoint_from, distance_between, distance_to, ellipse, envelope, farthest_point_to, farthest_to, geometry_collection, gini, hexagon, hierarchical_clustering, IDW, inside, inter, intersects, line, link, masked_by, moran, neighbors_at, neighbors_of, overlapping, overlaps, partially_overlaps, path_between, path_to, plan, points_along, points_at, points_on, polygon, polyhedron, pyramid, rectangle, rgb_to_xyz, rotated_by, round, scaled_to, set_z, simple_clustering_by_distance, simplification, skeletonize, smooth, sphere, split_at, split_geometry, split_lines, square, squircle, teapot, to_GAMA_CRS, to_rectangles, to_squares, touches, towards, transformed_by, translated_by, triangle, triangulate, union, using, voronoi, with_precision, without_holes,

Spatial properties operators

covers, crosses, intersects, partially_overlaps, touches,

Spatial queries operators

agent_closest_to, agent_farthest_to, agents_at_distance, agents_inside, agents_overlapping, at_distance, closest_to, farthest_to, inside, neighbors_at, neighbors_of, overlapping,

Spatial relations operators

direction_between, distance_between, distance_to, path_between, path_to, towards,

Spatial statistical operators

hierarchical_clustering, simple_clustering_by_distance,

Spatial transformations operators

-, [](#), +, as_4_grid, as_grid, as_hexagonal_grid, at_location, clean, convex_hull, CRS_transform, rotated_by, scaled_to, simplification, skeletonize, smooth, split_geometry, split_lines, to_GAMA_CRS, to_rectangles, to_squares, transformed_by, translated_by, triangulate, voronoi, without_holes,

index_of, last_index_of, of_generic_species, of_species,

Statistical operators

build, corR, dbscan, distribution_of, distribution2d_of, frequency_of, gamma_rnd, geometric_mean, gini, harmonic_mean, hierarchical_clustering, kmeans, kurtosis, max, mean, mean_deviation, meanR, median, min, moran, mul, predict, simple_clustering_by_distance, skewness, standard_deviation, sum, variance,

+, <, <=, >, >=, at, char, contains, contains_all, contains_any, copy_between, date, empty, first, in, indented_by, index_of, is_number, last, last_index_of, length, lower_case, replace, replace_regex, reverse, sample, shuffle, split_with, string, upper_case,

System

., command, copy, dead, eval_gaml, every, user_input,

date, string,

User control operators

user_input,

Operators

`-`

Possible use:

- (int) —> int
- (point) —> point
- (float) —> float
int - float —> float
- (int , float) —> float
int - int —> int
- (int , int) —> int
matrix - float —> matrix
- (matrix , float) —> matrix
float - matrix —> matrix
- (float , matrix) —> matrix
date - float —> date
- (date , float) —> date
species - agent —> container
- (species , agent) —> container
date - date —> float
- (date , date) —> float
matrix - matrix —> matrix
- (matrix , matrix) —> matrix
point - int —> point
- (point , int) —> point
date - int —> date
- (date , int) —> date
point - float —> point
- (point , float) —> point
float - float —> float
- (float , float) —> float
rgb - rgb —> rgb
- (rgb , rgb) —> rgb
int - matrix —> matrix
- (int , matrix) —> matrix
container - container —> container
- (container , container) —> container
rgb - int —> rgb
- (rgb , int) —> rgb
container - unknown —> container
- (container , unknown) —> container
point - point —> point
- (point , point) —> point
float - int —> float
- (float , int) —> float
geometry - geometry —> geometry
- (geometry , geometry) —> geometry
matrix - int —> matrix
- (matrix , int) —> matrix
geometry - float —> geometry
- (geometry , float) —> geometry
map - map —> map
- (map , map) —> map
map - pair —> map
- (map , pair) —> map
geometry - container<geometry> —> geometry
- (geometry , container<geometry>) —> geometry

Result:

Returns the difference of the two operands. If it is used as an unary operator, it returns the opposite of the operand.

Comment:

The behavior of the operator depends on the type of the operands.

Special cases:

if the left operand is a species and the right operand is an agent of the species, - returns a list containing all the agents of the species minus this agent
if both operands are containers and the right operand is empty, - returns the left operand
if both operands are numbers, performs a normal arithmetic difference and returns a float if one of them is a float.

int var7 <- 1 - 1; 	// var7 equals 0
int var8 <- 1.0 - 1; 	// var8 equals 0.0
int var9 <- 3.7 - 1.2; 	// var9 equals 2.5
int var10 <- 3 - 1.2; 	// var10 equals 1.8

if both operands are dates, returns the duration in seconds between date2 and date1. To obtain a more precise duration, in milliseconds, use milliseconds_between(date1, date2)

float var11 <- date1 - date2; 	// var11 equals 598

if one of the operands is a date and the other a number, returns a date corresponding to the date minus the given number as duration (in seconds)

date1 - 200

if left-hand operand is a point and the right-hand a number, returns a new point with each coordinate as the difference of the operand coordinate with this number.

point var13 <- {1, 2} - 4.5; 	// var13 equals {-3.5, -2.5, -4.5}
point var14 <- {1, 2} - 4; 	// var14 equals {-3.0,-2.0,-4.0}

if both operands are colors, returns a new color resulting from the subtraction of the two operands, component by component

rgb var15 <- rgb([255, 128, 32]) - rgb('red'); 	// var15 equals rgb([0,128,32])

if one operand is a matrix and the other a number (float or int), performs a normal arithmetic difference of the number with each element of the matrix (results are float if the number is a float.

matrix var16 <- 3.5 - matrix([[2,5],[3,4]]); 	// var16 equals matrix([[1.5,-1.5],[0.5,-0.5]])

if both operands are containers, returns a new list in which all the elements of the right operand have been removed from the left one

list<int> var17 <- [1,2,3,4,5,6] - [2,4,9]; 	// var17 equals [1,3,5,6]
list<int> var18 <- [1,2,3,4,5,6] - [0,8]; 	// var18 equals [1,2,3,4,5,6]

if one operand is a color and the other an integer, returns a new color resulting from the subtraction of each component of the color with the right operand

rgb var19 <- rgb([255, 128, 32]) - 3; 	// var19 equals rgb([252,125,29])

if the left operand is a list and the right operand is an object of any type (except list), - returns a list containing the elements of the left operand minus all the occurrences of this object

list<int> var20 <- [1,2,3,4,5,6] - 2; 	// var20 equals [1,3,4,5,6]
list<int> var21 <- [1,2,3,4,5,6] - 0; 	// var21 equals [1,2,3,4,5,6]

if both operands are points, returns their difference (coordinates per coordinates).

point var22 <- {1, 2} - {4, 5}; 	// var22 equals {-3.0, -3.0}

if both operands are a point, a geometry or an agent, returns the geometry resulting from the difference between both geometries

geometry var23 <- geom1 - geom2; 	// var23 equals a geometry corresponding to difference between geom1 and geom2

if the left-hand operand is a geometry and the right-hand operand a float, returns a geometry corresponding to the left-hand operand (geometry, agent, point) reduced by the right-hand operand distance

geometry var24 <- shape - 5; 	// var24 equals a geometry corresponding to the geometry of the agent applying the operator reduced by a distance of 5

if the right-operand is a list of points, geometries or agents, returns the geometry resulting from the difference between the left-geometry and all of the right-geometries

geometry var25 <- rectangle(10,10) - [circle(2), square(2)]; 	// var25 equals rectangle(10,10) - (circle(2) + square(2))

Examples:

int var0 <- - (-56); 	// var0 equals 56
point var1 <- -{3.0,5.0}; 	// var1 equals {-3.0,-5.0}
point var2 <- -{1.0,6.0,7.0}; 	// var2 equals {-1.0,-6.0,-7.0}
map var3 <- ['a'::1,'b'::2] - ['b'::2]; 	// var3 equals ['a'::1]
map var4 <- ['a'::1,'b'::2] - ['b'::2,'c'::3]; 	// var4 equals ['a'::1]
map var5 <- ['a'::1,'b'::2] - ('b'::2); 	// var5 equals ['a'::1]
map var6 <- ['a'::1,'b'::2] - ('c'::3); 	// var6 equals ['a'::1,'b'::2]

`:`

Possible use:

unknown : unknown —> unknown
: (unknown , unknown) —> unknown

`::`

Possible use:

any expression :: any expression —> pair
:: (any expression , any expression) —> pair

Result:

produces a new pair combining the left and the right operands

Special cases:

nil is not acceptable as a key (although it is as a value). If such a case happens, :: will throw an appropriate error

`!`

Possible use:

! (bool) —> bool

Result:

opposite boolean value.

Special cases:

if the parameter is not boolean, it is casted to a boolean value.

Examples:

bool var0 <- ! (true); 	// var0 equals false

`!=`

Possible use:

float != float —> bool
!= (float , float) —> bool
unknown != unknown —> bool
!= (unknown , unknown) —> bool
date != date —> bool
!= (date , date) —> bool
float != int —> bool
!= (float , int) —> bool
int != float —> bool
!= (int , float) —> bool

Result:

true if both operands are different, false otherwise

Examples:

bool var0 <- 3.0 != 3.0; 	// var0 equals false
bool var1 <- 4.0 != 4.7; 	// var1 equals true
bool var2 <- [2,3] != [2,3]; 	// var2 equals false
bool var3 <- [2,4] != [2,3]; 	// var3 equals true
#now != #now minus_hours 1 :- true
bool var5 <- 3.0 != 3; 	// var5 equals false
bool var6 <- 4.7 != 4; 	// var6 equals true
bool var7 <- 3 != 3.0; 	// var7 equals false
bool var8 <- 4 != 4.7; 	// var8 equals true

`?`

Possible use:

bool ? any expression —> unknown
? (bool , any expression) —> unknown

Result:

It is used in combination with the : operator: if the left-hand operand evaluates to true, returns the value of the left-hand operand of the :, otherwise that of the right-hand operand of the :

Comment:

These functional tests can be combined together.

Examples:

list<string> var0 <- [10, 19, 43, 12, 7, 22] collect ((each > 20) ? 'above' : 'below'); 	// var0 equals ['below', 'below', 'above', 'below', 'below', 'above']
rgb color <- (flip(0.3) ? #red : (flip(0.9) ? #blue : #green));

`/`

Possible use:

rgb / float —> rgb
/ (rgb , float) —> rgb
float / int —> float
/ (float , int) —> float
point / float —> point
/ (point , float) —> point
int / int —> float
/ (int , int) —> float
int / float —> float
/ (int , float) —> float
matrix / float —> matrix
/ (matrix , float) —> matrix
point / int —> point
/ (point , int) —> point
matrix / matrix —> matrix
/ (matrix , matrix) —> matrix
matrix / int —> matrix
/ (matrix , int) —> matrix
float / float —> float
/ (float , float) —> float
rgb / int —> rgb
/ (rgb , int) —> rgb

Result:

Returns the division of the two operands.

Special cases:

if the right-hand operand is equal to zero, raises a “Division by zero” exception
if one operand is a color and the other a double, returns a new color resulting from the division of each component of the color by the right operand. The result on each component is then truncated.

rgb var0 <- rgb([255, 128, 32]) / 2.5; 	// var0 equals rgb([102,51,13])

if the left operand is a point, returns a new point with coordinates divided by the right operand

point var1 <- {5, 7.5} / 2.5; 	// var1 equals {2, 3}
point var2 <- {2,5} / 4; 	// var2 equals {0.5,1.25}

if both operands are numbers (float or int), performs a normal arithmetic division and returns a float.

float var3 <- 3 / 5.0; 	// var3 equals 0.6

if one operand is a color and the other an integer, returns a new color resulting from the division of each component of the color by the right operand

rgb var4 <- rgb([255, 128, 32]) / 2; 	// var4 equals rgb([127,64,16])

`.`

Possible use:

matrix . matrix —> matrix
. (matrix , matrix) —> matrix
agent . any expression —> unknown
. (agent , any expression) —> unknown

Result:

It has two different uses: it can be the dot product between 2 matrices or return an evaluation of the expression (right-hand operand) in the scope the given agent.

Special cases:

if the agent is nil or dead, throws an exception
if both operands are matrix, returns the dot product of them

matrix var0 <- matrix([[1,1],[1,2]]) . matrix([[1,1],[1,2]]); 	// var0 equals matrix([[2,3],[3,5]])

if the left operand is an agent, it evaluates of the expression (right-hand operand) in the scope the given agent

unknown var1 <- agent1.location; 	// var1 equals the location of the agent agent1
map(nil).keys

`^`

Possible use:

int ^ float —> float
^ (int , float) —> float
float ^ float —> float
^ (float , float) —> float
int ^ int —> float
^ (int , int) —> float
float ^ int —> float
^ (float , int) —> float

Result:

Returns the value (always a float) of the left operand raised to the power of the right operand.

Special cases:

if the right-hand operand is equal to 0, returns 1
if it is equal to 1, returns the left-hand operand.
Various examples of power

float var1 <- 2 ^ 3; 	// var1 equals 8.0

Examples:

float var0 <- 4.84 ^ 0.5; 	// var0 equals 2.2

`@`

Same signification as at

`*`

Possible use:

int * int —> int
* (int , int) —> int
matrix * int —> matrix
* (matrix , int) —> matrix
point * point —> float
* (point , point) —> float
int * float —> float
* (int , float) —> float
float * float —> float
* (float , float) —> float
matrix * matrix —> matrix
* (matrix , matrix) —> matrix
point * int —> point
* (point , int) —> point
float * matrix —> matrix
* (float , matrix) —> matrix
geometry * point —> geometry
* (geometry , point) —> geometry
point * float —> point
* (point , float) —> point
int * matrix —> matrix
* (int , matrix) —> matrix
float * int —> float
* (float , int) —> float
rgb * int —> rgb
* (rgb , int) —> rgb
matrix * float —> matrix
* (matrix , float) —> matrix
geometry * float —> geometry
* (geometry , float) —> geometry

Result:

Returns the product of the two operands.

Special cases:

if both operands are numbers (float or int), performs a normal arithmetic product and returns a float if one of them is a float.

int var1 <- 1 * 1; 	// var1 equals 1

if both operands are points, returns their scalar product

float var2 <- {2,5} * {4.5, 5}; 	// var2 equals 34.0

if the left-hand operator is a point and the right-hand a number, returns a point with coordinates multiplied by the number

point var3 <- {2,5} * 4; 	// var3 equals {8.0, 20.0}
point var4 <- {2, 4} * 2.5; 	// var4 equals {5.0, 10.0}

if the left-hand operand is a geometry and the right-hand operand a point, returns a geometry corresponding to the left-hand operand (geometry, agent, point) scaled by the right-hand operand coefficients in the 3 dimensions

geometry var5 <- shape * {0.5,0.5,2}; 	// var5 equals a geometry corresponding to the geometry of the agent applying the operator scaled by a coefficient of 0.5 in x, 0.5 in y and 2 in z

if one operand is a matrix and the other a number (float or int), performs a normal arithmetic product of the number with each element of the matrix (results are float if the number is a float.

matrix<float> m <- (3.5 * matrix([[2,5],[3,4]]));	//m equals matrix([[7.0,17.5],[10.5,14]])

if one operand is a color and the other an integer, returns a new color resulting from the product of each component of the color with the right operand (with a maximum value at 255)

rgb var7 <- rgb([255, 128, 32]) * 2; 	// var7 equals rgb([255,255,64])

if the left-hand operand is a geometry and the right-hand operand a float, returns a geometry corresponding to the left-hand operand (geometry, agent, point) scaled by the right-hand operand coefficient

geometry var8 <- circle(10) * 2; 	// var8 equals circle(20)

Examples:

float var0 <- 2.5 * 2; 	// var0 equals 5.0

`+`

Possible use:

string + string —> string
+ (string , string) —> string
date + float —> date
+ (date , float) —> date
map + pair —> map
+ (map , pair) —> map
int + matrix —> matrix
+ (int , matrix) —> matrix
point + int —> point
+ (point , int) —> point
rgb + rgb —> rgb
+ (rgb , rgb) —> rgb
geometry + float —> geometry
+ (geometry , float) —> geometry
matrix + float —> matrix
+ (matrix , float) —> matrix
geometry + geometry —> geometry
+ (geometry , geometry) —> geometry
map + map —> map
+ (map , map) —> map
float + float —> float
+ (float , float) —> float
float + int —> float
+ (float , int) —> float
matrix + matrix —> matrix
+ (matrix , matrix) —> matrix
date + string —> string
+ (date , string) —> string
matrix + int —> matrix
+ (matrix , int) —> matrix
int + int —> int
+ (int , int) —> int
string + unknown —> string
+ (string , unknown) —> string
point + point —> point
+ (point , point) —> point
float + matrix —> matrix
+ (float , matrix) —> matrix
int + float —> float
+ (int , float) —> float
point + float —> point
+ (point , float) —> point
rgb + int —> rgb
+ (rgb , int) —> rgb
date + int —> date
+ (date , int) —> date
container + container —> container
+ (container , container) —> container
container + unknown —> container
+ (container , unknown) —> container
+ (geometry, float, int) —> geometry
+ (geometry, float, int, int) —> geometry

Result:

Returns the sum, union or concatenation of the two operands.

Special cases:

if one of the operands is nil, + throws an error
if both operands are species, returns a special type of list called meta-population
if the left-hand operand is a geometry and the right-hand operands a float and an integer, returns a geometry corresponding to the left-hand operand (geometry, agent, point) enlarged by the first right-hand operand (distance), using a number of segments equal to the second right-hand operand

geometry var4 <- circle(5) + (5,32); 	// var4 equals circle(10)

if one operand is a matrix and the other a number (float or int), performs a normal arithmetic sum of the number with each element of the matrix (results are float if the number is a float.

matrix var5 <- 3.5 + matrix([[2,5],[3,4]]); 	// var5 equals matrix([[5.5,8.5],[6.5,7.5]])

if both operands are colors, returns a new color resulting from the sum of the two operands, component by component

rgb var6 <- rgb([255, 128, 32]) + rgb('red'); 	// var6 equals rgb([255,128,32])

if the left-hand operand is a geometry and the right-hand operand a float, returns a geometry corresponding to the left-hand operand (geometry, agent, point) enlarged by the right-hand operand distance. The number of segments used by default is 8 and the end cap style is #round

geometry var7 <- circle(5) + 5; 	// var7 equals circle(10)

if the right-operand is a point, a geometry or an agent, returns the geometry resulting from the union between both geometries

geometry var8 <- geom1 + geom2; 	// var8 equals a geometry corresponding to union between geom1 and geom2

if both operands are numbers (float or int), performs a normal arithmetic sum and returns a float if one of them is a float.

int var9 <- 1 + 1; 	// var9 equals 2
int var10 <- 1.0 + 1; 	// var10 equals 2.0
int var11 <- 1.0 + 2.5; 	// var11 equals 3.5

if the left-hand operand is a string, returns the concatenation of the two operands (the left-hand one beind casted into a string)

string var12 <- "hello " + 12; 	// var12 equals "hello 12"

if both operands are points, returns their sum.

point var13 <- {1, 2} + {4, 5}; 	// var13 equals {5.0, 7.0}

if the left-hand operand is a point and the right-hand a number, returns a new point with each coordinate as the sum of the operand coordinate with this number.

point var14 <- {1, 2} + 4; 	// var14 equals {5.0, 6.0,4.0}
point var15 <- {1, 2} + 4.5; 	// var15 equals {5.5, 6.5,4.5}

if one operand is a color and the other an integer, returns a new color resulting from the sum of each component of the color with the right operand

rgb var16 <- rgb([255, 128, 32]) + 3; 	// var16 equals rgb([255,131,35])

if the left-hand operand is a geometry and the right-hand operands a float, an integer and one of #round, #square or #flat, returns a geometry corresponding to the left-hand operand (geometry, agent, point) enlarged by the first right-hand operand (distance), using a number of segments equal to the second right-hand operand and a flat, square or round end cap style

geometry var17 <- circle(5) + (5,32,#round); 	// var17 equals circle(10)

if one of the operands is a date and the other a number, returns a date corresponding to the date plus the given number as duration (in seconds)

date1 + 200

if both operands are list, +returns the concatenation of both lists.

list<int> var19 <- [1,2,3,4,5,6] + [2,4,9]; 	// var19 equals [1,2,3,4,5,6,2,4,9]
list<int> var20 <- [1,2,3,4,5,6] + [0,8]; 	// var20 equals [1,2,3,4,5,6,0,8]

if the right operand is an object of any type (except a container), + returns a list of the elements of the left operand, to which this object has been added

list<int> var21 <- [1,2,3,4,5,6] + 2; 	// var21 equals [1,2,3,4,5,6,2]
list<int> var22 <- [1,2,3,4,5,6] + 0; 	// var22 equals [1,2,3,4,5,6,0]

Examples:

map var0 <- ['a'::1,'b'::2] + ('c'::3); 	// var0 equals ['a'::1,'b'::2,'c'::3]
map var1 <- ['a'::1,'b'::2] + ('c'::3); 	// var1 equals ['a'::1,'b'::2,'c'::3]
map var2 <- ['a'::1,'b'::2] + ['c'::3]; 	// var2 equals ['a'::1,'b'::2,'c'::3]
map var3 <- ['a'::1,'b'::2] + [5::3.0]; 	// var3 equals ['a'::1.0,'b'::2.0,5::3.0]

`<`

Possible use:

float < int —> bool
< (float , int) —> bool
int < int —> bool
< (int , int) —> bool
point < point —> bool
< (point , point) —> bool
int < float —> bool
< (int , float) —> bool
date < date —> bool
< (date , date) —> bool
float < float —> bool
< (float , float) —> bool
string < string —> bool
< (string , string) —> bool

Result:

true if the left-hand operand is less than the right-hand operand, false otherwise.

Special cases:

if one of the operands is nil, returns false
if both operands are points, returns true if and only if the left component (x) of the left operand if less than or equal to x of the right one and if the right component (y) of the left operand is greater than or equal to y of the right one.

bool var5 <- {5,7} < {4,6}; 	// var5 equals false
bool var6 <- {5,7} < {4,8}; 	// var6 equals false

if both operands are String, uses a lexicographic comparison of two strings

bool var7 <- 'abc' < 'aeb'; 	// var7 equals true

Examples:

bool var0 <- 3.5 < 7; 	// var0 equals true
bool var1 <- 3 < 7; 	// var1 equals true
bool var2 <- 3 < 2.5; 	// var2 equals false
#now < #now minus_hours 1 :- false
bool var4 <- 3.5 < 7.6; 	// var4 equals true

`<=`

Possible use:

string <= string —> bool
<= (string , string) —> bool
date <= date —> bool
<= (date , date) —> bool
float <= float —> bool
<= (float , float) —> bool
int <= int —> bool
<= (int , int) —> bool
int <= float —> bool
<= (int , float) —> bool
float <= int —> bool
<= (float , int) —> bool
point <= point —> bool
<= (point , point) —> bool

Result:

true if the left-hand operand is less or equal than the right-hand operand, false otherwise.

Special cases:

if one of the operands is nil, returns false
if both operands are String, uses a lexicographic comparison of two strings

bool var5 <- 'abc' <= 'aeb'; 	// var5 equals true

if both operands are points, returns true if and only if the left component (x) of the left operand if less than or equal to x of the right one and if the right component (y) of the left operand is greater than or equal to y of the right one.

bool var6 <- {5,7} <= {4,6}; 	// var6 equals false
bool var7 <- {5,7} <= {4,8}; 	// var7 equals false

Examples:

#now <= #now minus_hours 1 :- false
bool var1 <- 3.5 <= 3.5; 	// var1 equals true
bool var2 <- 3 <= 7; 	// var2 equals true
bool var3 <- 3 <= 2.5; 	// var3 equals false
bool var4 <- 7.0 <= 7; 	// var4 equals true

`<>`

Same signification as !=

`=`

Possible use:

date = date —> bool
= (date , date) —> bool
int = float —> bool
= (int , float) —> bool
unknown = unknown —> bool
= (unknown , unknown) —> bool
float = float —> bool
= (float , float) —> bool
float = int —> bool
= (float , int) —> bool
int = int —> bool
= (int , int) —> bool

Result:

returns true if both operands are equal, false otherwise returns true if both operands are equal, false otherwise

Special cases:

if both operands are any kind of objects, returns true if they are identical (i.e., the same object) or equal (comparisons between nil values are permitted)

bool var0 <- [2,3] = [2,3]; 	// var0 equals true

Examples:

#now = #now minus_hours 1 :- false
bool var2 <- 3 = 3.0; 	// var2 equals true
bool var3 <- 4 = 4.7; 	// var3 equals false
bool var4 <- 4.5 = 4.7; 	// var4 equals false
bool var5 <- 4.7 = 4; 	// var5 equals false
bool var6 <- 4 = 5; 	// var6 equals false

`>`

Possible use:

int > float —> bool
> (int , float) —> bool
float > float —> bool
> (float , float) —> bool
string > string —> bool
> (string , string) —> bool
int > int —> bool
> (int , int) —> bool
date > date —> bool
> (date , date) —> bool
point > point —> bool
> (point , point) —> bool
float > int —> bool
> (float , int) —> bool

Result:

true if the left-hand operand is greater than the right-hand operand, false otherwise.

Special cases:

if one of the operands is nil, returns false
if both operands are String, uses a lexicographic comparison of two strings

bool var0 <- 'abc' > 'aeb'; 	// var0 equals false

if both operands are points, returns true if and only if the left component (x) of the left operand if greater than x of the right one and if the right component (y) of the left operand is greater than y of the right one.

bool var1 <- {5,7} > {4,6}; 	// var1 equals true
bool var2 <- {5,7} > {4,8}; 	// var2 equals false

Examples:

bool var3 <- 3 > 2.5; 	// var3 equals true
bool var4 <- 3.5 > 7.6; 	// var4 equals false
bool var5 <- 3 > 7; 	// var5 equals false
#now > #now minus_hours 1 :- true
bool var7 <- 3.5 > 7; 	// var7 equals false

`>=`

Possible use:

float >= int —> bool
>= (float , int) —> bool
int >= int —> bool
>= (int , int) —> bool
int >= float —> bool
>= (int , float) —> bool
string >= string —> bool
>= (string , string) —> bool
date >= date —> bool
>= (date , date) —> bool
float >= float —> bool
>= (float , float) —> bool
point >= point —> bool
>= (point , point) —> bool

Result:

true if the left-hand operand is greater or equal than the right-hand operand, false otherwise.

Special cases:

if one of the operands is nil, returns false
if both operands are string, uses a lexicographic comparison of the two strings

bool var5 <- 'abc' >= 'aeb'; 	// var5 equals false
bool var6 <- 'abc' >= 'abc'; 	// var6 equals true

if both operands are points, returns true if and only if the left component (x) of the left operand if greater or equal than x of the right one and if the right component (y) of the left operand is greater than or equal to y of the right one.

bool var7 <- {5,7} >= {4,6}; 	// var7 equals true
bool var8 <- {5,7} >= {4,8}; 	// var8 equals false

Examples:

bool var0 <- 3.5 >= 7; 	// var0 equals false
bool var1 <- 3 >= 7; 	// var1 equals false
bool var2 <- 3 >= 2.5; 	// var2 equals true
#now >= #now minus_hours 1 :- true
bool var4 <- 3.5 >= 3.5; 	// var4 equals true

`abs`

Possible use:

abs (int) —> int
abs (float) —> float

Result:

Returns the absolute value of the operand (so a positive int or float depending on the type of the operand).

Examples:

int var0 <- abs (-10); 	// var0 equals 10
int var1 <- abs (10); 	// var1 equals 10
float var3 <- abs (200 * -1 + 0.5); 	// var3 equals 199.5

`accumulate`

Possible use:

container accumulate any expression —> container
accumulate (container , any expression) —> container

Result:

returns a new flat list, in which each element is the evaluation of the right-hand operand. If this evaluation returns a list, the elements of this result are added directly to the list returned

Comment:

accumulate is dedicated to the application of a same computation on each element of a container (and returns a list). In the right-hand operand, the keyword each can be used to represent, in turn, each of the left-hand operand elements.

Examples:

container var0 <- [a1,a2,a3] accumulate (each neighbors_at 10); 	// var0 equals a flat list of all the neighbors of these three agents
list<int> var1 <- [1,2,4] accumulate ([2,4]); 	// var1 equals [2,4,2,4,2,4]
list<int> var2 <- [1,2,4] accumulate (each * 2); 	// var2 equals [2,4,8]

`acos`

Possible use:

acos (float) —> float
acos (int) —> float

Result:

Returns the value (in the interval [0,180], in decimal degrees) of the arccos of the operand (which should be in [-1,1]).

Special cases:

if the right-hand operand is outside of the [-1,1] interval, returns NaN

Examples:

float var0 <- acos (0); 	// var0 equals 90.0

`action`

Possible use:

action (any) —> action

Result:

Casts the operand into the type action

`add_days`

Same signification as plus_days

`add_edge`

Possible use:

graph add_edge pair —> graph
add_edge (graph , pair) —> graph

Result:

add an edge between a source vertex and a target vertex (resp. the left and the right element of the pair operand)

Comment:

if the edge already exists, the graph is unchanged

Examples:

graph <- graph add_edge (source::target);

`add_hours`

Same signification as plus_hours

`add_minutes`

Same signification as plus_minutes

`add_months`

Same signification as plus_months

`add_ms`

Same signification as plus_ms

`add_node`

Possible use:

graph add_node geometry —> graph
add_node (graph , geometry) —> graph

Result:

adds a node in a graph.

Examples:

graph var0 <- graph add_node node(0) ; 	// var0 equals the graph with node(0)

`add_point`

Possible use:

geometry add_point point —> geometry
add_point (geometry , point) —> geometry

Result:

A new geometry resulting from the addition of the right point (coordinate) to the left-hand geometry. Note that adding a point to a line or polyline will always return a closed contour. Also note that the position at which the added point will appear in the geometry is not necessarily the last one, as points are always ordered in a clockwise fashion in geometries

Examples:

geometry var0 <- polygon([{10,10},{10,20},{20,20}]) add_point {20,10}; 	// var0 equals polygon([{10,10},{10,20},{20,20},{20,10}])

`add_seconds`

Same signification as +

`add_weeks`

Same signification as plus_weeks

`add_years`

Same signification as plus_years

`adjacency`

Possible use:

adjacency (graph) —> matrix<float>

Result:

adjacency matrix of the given graph.

`after`

Possible use:

after (date) —> bool
any expression after date —> bool
after (any expression , date) —> bool

Result:

Returns true if the current_date of the model is strictly after the date passed in argument. Synonym of ‘current_date > argument’. Can be used in its composed form with 2 arguments to express the lower boundary for the computation of a frequency. Note that only dates strictly after this one will be tested against the frequency

Examples:

reflex when: after(starting_date) {} -: will always be run after the first step
reflex when: false after(starting date + #10days) {} -: will not be run after this date. Better to use 'until' or 'before' in that case
every(2#days) after (starting_date + 1#day) // the computation will return true every two days (using the starting_date of the model as the starting point) only for the dates strictly after this starting_date + 1#day

`agent`

Possible use:

agent (any) —> agent

Result:

Casts the operand into the type agent

`agent_closest_to`

Possible use:

agent_closest_to (unknown) —> agent

Result:

An agent, the closest to the operand (casted as a geometry).

Comment:

the distance is computed in the topology of the calling agent (the agent in which this operator is used), with the distance algorithm specific to the topology.

Examples:

agent var0 <- agent_closest_to(self); 	// var0 equals the closest agent to the agent applying the operator.

`agent_farthest_to`

Possible use:

agent_farthest_to (unknown) —> agent

Result:

An agent, the farthest to the operand (casted as a geometry).

Comment:

the distance is computed in the topology of the calling agent (the agent in which this operator is used), with the distance algorithm specific to the topology.

Examples:

agent var0 <- agent_farthest_to(self); 	// var0 equals the farthest agent to the agent applying the operator.

`agent_from_geometry`

Possible use:

path agent_from_geometry geometry —> agent
agent_from_geometry (path , geometry) —> agent

Result:

returns the agent corresponding to given geometry (right-hand operand) in the given path (left-hand operand).

Special cases:

if the left-hand operand is nil, returns nil

Examples:

geometry line <- one_of(path_followed.segments);
road ag <- road(path_followed agent_from_geometry line);

`agents_at_distance`

Possible use:

agents_at_distance (float) —> container

Result:

A list of agents situated at a distance lower than the right argument.

Examples:

container var0 <- agents_at_distance(20); 	// var0 equals all the agents (excluding the caller) which distance to the caller is lower than 20

`agents_inside`

Possible use:

agents_inside (unknown) —> list<agent>

Result:

A list of agents covered by the operand (casted as a geometry).

Examples:

list<agent> var0 <- agents_inside(self); 	// var0 equals the agents that are covered by the shape of the agent applying the operator.

`agents_overlapping`

Possible use:

agents_overlapping (unknown) —> list<agent>

Result:

A list of agents overlapping the operand (casted as a geometry).

Examples:

list<agent> var0 <- agents_overlapping(self); 	// var0 equals the agents that overlap the shape of the agent applying the operator.

`all_pairs_shortest_path`

Possible use:

all_pairs_shortest_path (graph) —> matrix<int>

Result:

returns the successor matrix of shortest paths between all node pairs (rows: source, columns: target): a cell (i,j) will thus contains the next node in the shortest path between i and j.

Examples:

matrix<int> var0 <- all_pairs_shortest_paths(my_graph); 	// var0 equals shortest_paths_matrix will contain all pairs of shortest paths

`alpha_index`

Possible use:

alpha_index (graph) —> float

Result:

returns the alpha index of the graph (measure of connectivity which evaluates the number of cycles in a graph in comparison with the maximum number of cycles. The higher the alpha index, the more a network is connected: alpha = nb_cycles / (2*S-5) - planar graph)

Examples:

float var1 <- alpha_index(graphEpidemio); 	// var1 equals the alpha index of the graph

`among`

Possible use:

int among container —> container
among (int , container) —> container

Result:

Returns a list of length the value of the left-hand operand, containing random elements from the right-hand operand. As of GAMA 1.6, the order in which the elements are returned can be different than the order in which they appear in the right-hand container

Special cases:

if the right-hand operand is empty, among returns a new empty list. If it is nil, it throws an error.
if the left-hand operand is greater than the length of the right-hand operand, among returns the right-hand operand (converted as a list). If it is smaller or equal to zero, it returns an empty list

Examples:

list<int> var0 <- 3 among [1,2,4,3,5,7,6,8]; 	// var0 equals [1,2,8] (for example)
container var1 <- 3 among g2; 	// var1 equals [node6,node11,node7]
container var2 <- 3 among list(node); 	// var2 equals [node1,node11,node4]
list<int> var3 <- 1 among [1::2,3::4]; 	// var3 equals 2 or 4

`and`

Possible use:

bool and any expression —> bool
and (bool , any expression) —> bool

Result:

a bool value, equal to the logical and between the left-hand operand and the right-hand operand.

Comment:

both operands are always casted to bool before applying the operator. Thus, an expression like (1 and 0) is accepted and returns false.

`and`

Possible use:

predicate and predicate —> predicate
and (predicate , predicate) —> predicate

Result:

create a new predicate from two others by including them as subintentions

Examples:

predicate1 and predicate2

`angle_between`

Possible use:

angle_between (point, point, point) —> int

Result:

the angle between vectors P0P1 and P0P2 (P0, P1, P2 being the three point operands)

Examples:

int var0 <- angle_between({5,5},{10,5},{5,10}); 	// var0 equals 90

`any`

Same signification as one_of

`any_location_in`

Possible use:

any_location_in (geometry) —> point

Result:

A point inside (or touching) the operand-geometry.

Examples:

point var0 <- any_location_in(square(5)); 	// var0 equals a point in the square, for example : {3,4.6}.

`any_point_in`

Same signification as any_location_in

`append_horizontally`

Possible use:

matrix append_horizontally matrix —> matrix
append_horizontally (matrix , matrix) —> matrix
matrix append_horizontally matrix —> matrix
append_horizontally (matrix , matrix) —> matrix

Result:

A matrix resulting from the concatenation of the rows of the two given matrices. If not both numerical or both object matrices, returns the first matrix.

Examples:

matrix var0 <- matrix([[1.0,2.0],[3.0,4.0]]) append_horizontally matrix([[1,2],[3,4]]); 	// var0 equals matrix([[1.0,2.0],[3.0,4.0],[1.0,2.0],[3.0,4.0]])

`append_vertically`

Possible use:

matrix append_vertically matrix —> matrix
append_vertically (matrix , matrix) —> matrix
matrix append_vertically matrix —> matrix
append_vertically (matrix , matrix) —> matrix

Result:

A matrix resulting from the concatenation of the columns of the two given matrices. If not both numerical or both object matrices, returns the first matrix.

Examples:

matrix var0 <- matrix([[1,2],[3,4]]) append_vertically matrix([[1,2],[3,4]]); 	// var0 equals matrix([[1,2,1,2],[3,4,3,4]])

`arc`

Possible use:

arc (float, float, float) —> geometry
arc (float, float, float, bool) —> geometry

Result:

An arc, which radius is equal to the first operand, heading to the second and amplitude the third An arc, which radius is equal to the first operand, heading to the second, amplitude to the third and a boolean indicating whether to return a linestring or a polygon to the fourth

Comment:

the center of the arc is by default the location of the current agent in which has been called this operator. This operator returns a polygon by default.the center of the arc is by default the location of the current agent in which has been called this operator.

Special cases:

returns a point if the radius operand is lower or equal to 0.
returns a point if the radius operand is lower or equal to 0.

Examples:

geometry var0 <- arc(4,45,90); 	// var0 equals a geometry as an arc of radius 4, in a direction of 45Â° and an amplitude of 90Â°
geometry var1 <- arc(4,45,90, false); 	// var1 equals a geometry as an arc of radius 4, in a direction of 45Â° and an amplitude of 90Â°, which only contains the points on the arc

`around`

Possible use:

float around unknown —> geometry
around (float , unknown) —> geometry

Result:

A geometry resulting from the difference between a buffer around the right-operand casted in geometry at a distance left-operand (right-operand buffer left-operand) and the right-operand casted as geometry.

Special cases:

returns a circle geometry of radius right-operand if the left-operand is nil

Examples:

geometry var0 <- 10 around circle(5); 	// var0 equals the ring geometry between 5 and 10.

`as`

Possible use:

unknown as any expression —> unknown
as (unknown , any expression) —> unknown

Result:

casting of the first argument into a given type

Comment:

It is equivalent to the application of the type operator on the left operand.

Examples:

int var0 <- 3.5 as int; 	// var0 equals int(3.5)

`as_4_grid`

Possible use:

geometry as_4_grid point —> matrix
as_4_grid (geometry , point) —> matrix

Result:

A matrix of square geometries (grid with 4-neighborhood) with dimension given by the right-hand operand ({nb_cols, nb_lines}) corresponding to the square tessellation of the left-hand operand geometry (geometry, agent)

Examples:

matrix var0 <- self as_4_grid {10, 5}; 	// var0 equals the matrix of square geometries (grid with 4-neighborhood) with 10 columns and 5 lines corresponding to the square tessellation of the geometry of the agent applying the operator.

`as_distance_graph`

Possible use:

container as_distance_graph map —> graph
as_distance_graph (container , map) —> graph
container as_distance_graph float —> graph
as_distance_graph (container , float) —> graph
as_distance_graph (container, float, species) —> graph

Result:

creates a graph from a list of vertices (left-hand operand). An edge is created between each pair of vertices close enough (less than a distance, right-hand operand).

Comment:

as_distance_graph is more efficient for a list of points than as_intersection_graph.

Examples:

list(ant) as_distance_graph 3.0

`as_driving_graph`

Possible use:

container as_driving_graph container —> graph
as_driving_graph (container , container) —> graph

Result:

creates a graph from the list/map of edges given as operand and connect the node to the edge

Examples:

as_driving_graph(road,node)  --:  build a graph while using the road agents as edges and the node agents as nodes

`as_edge_graph`

Possible use:

as_edge_graph (map) —> graph
as_edge_graph (container) —> graph
container as_edge_graph float —> graph
as_edge_graph (container , float) —> graph

Result:

creates a graph from the list/map of edges given as operand

Special cases:

if the operand is a map, the graph will be built by creating edges from pairs of the map

graph var0 <- as_edge_graph([{1,5}::{12,45},{12,45}::{34,56}]); 	// var0 equals a graph with these three vertices and two edges

if the operand is a list and a tolerance (max distance in meters to consider that 2 points are the same node) is given, the graph will be built with elements of the list as edges and two edges will be connected by a node if the distance between their extremity (first or last points) are at distance lower or equal to the tolerance

graph var1 <- as_edge_graph([line([{1,5},{12,45}]),line([{13,45},{34,56}])],1);; 	// var1 equals a graph with two edges and three vertices

if the operand is a list, the graph will be built with elements of the list as edges

graph var2 <- as_edge_graph([line([{1,5},{12,45}]),line([{12,45},{34,56}])]); 	// var2 equals a graph with two edges and three vertices

`as_grid`

Possible use:

geometry as_grid point —> matrix
as_grid (geometry , point) —> matrix

Result:

A matrix of square geometries (grid with 8-neighborhood) with dimension given by the right-hand operand ({nb_cols, nb_lines}) corresponding to the square tessellation of the left-hand operand geometry (geometry, agent)

Examples:

matrix var0 <- self as_grid {10, 5}; 	// var0 equals a matrix of square geometries (grid with 8-neighborhood) with 10 columns and 5 lines corresponding to the square tessellation of the geometry of the agent applying the operator.

`as_hexagonal_grid`

Possible use:

geometry as_hexagonal_grid point —> list<geometry>
as_hexagonal_grid (geometry , point) —> list<geometry>

Result:

A list of geometries (hexagonal) corresponding to the hexagonal tesselation of the first operand geometry

Examples:

list<geometry> var0 <- self as_hexagonal_grid {10, 5}; 	// var0 equals list of geometries (hexagonal) corresponding to the hexagonal tesselation of the first operand geometry

`as_int`

Possible use:

string as_int int —> int
as_int (string , int) —> int

Result:

parses the string argument as a signed integer in the radix specified by the second argument.

Special cases:

if the left operand is nil or empty, as_int returns 0
if the left operand does not represent an integer in the specified radix, as_int throws an exception

Examples:

int var0 <- '20' as_int 10; 	// var0 equals 20
int var1 <- '20' as_int 8; 	// var1 equals 16
int var2 <- '20' as_int 16; 	// var2 equals 32
int var3 <- '1F' as_int 16; 	// var3 equals 31
int var4 <- 'hello' as_int 32; 	// var4 equals 18306744

`as_intersection_graph`

Possible use:

container as_intersection_graph float —> graph
as_intersection_graph (container , float) —> graph

Result:

creates a graph from a list of vertices (left-hand operand). An edge is created between each pair of vertices with an intersection (with a given tolerance).

Comment:

as_intersection_graph is more efficient for a list of geometries (but less accurate) than as_distance_graph.

Examples:

list(ant) as_intersection_graph 0.5

`as_map`

Possible use:

container as_map any expression —> map
as_map (container , any expression) —> map

Result:

produces a new map from the evaluation of the right-hand operand for each element of the left-hand operand

Comment:

the right-hand operand should be a pair

Special cases:

if the left-hand operand is nil, as_map throws an error.

Examples:

map<int,int> var0 <- [1,2,3,4,5,6,7,8] as_map (each::(each * 2)); 	// var0 equals [1::2, 2::4, 3::6, 4::8, 5::10, 6::12, 7::14, 8::16]
map<int,int> var1 <- [1::2,3::4,5::6] as_map (each::(each * 2)); 	// var1 equals [2::4, 4::8, 6::12]

`as_matrix`

Possible use:

unknown as_matrix point —> matrix
as_matrix (unknown , point) —> matrix

Result:

casts the left operand into a matrix with right operand as preferred size

Comment:

This operator is very useful to cast a file containing raster data into a matrix.Note that both components of the right operand point should be positive, otherwise an exception is raised.The operator as_matrix creates a matrix of preferred size. It fills in it with elements of the left operand until the matrix is full If the size is to short, some elements will be omitted. Matrix remaining elements will be filled in by nil.

Special cases:

if the right operand is nil, as_matrix is equivalent to the matrix operator

`as_path`

Possible use:

list<geometry> as_path graph —> path
as_path (list<geometry> , graph) —> path

Result:

create a graph path from the list of shape

Examples:

path var0 <- [road1,road2,road3] as_path my_graph; 	// var0 equals a path road1->road2->road3 of my_graph

`asin`

Possible use:

asin (float) —> float
asin (int) —> float

Result:

the arcsin of the operand

Special cases:

if the right-hand operand is outside of the [-1,1] interval, returns NaN

Examples:

float var0 <- asin (0); 	// var0 equals 0.0
float var1 <- asin (90); 	// var1 equals #nan

`at`

Possible use:

string at int —> string
at (string , int) —> string
container<KeyType,ValueType> at KeyType —> ValueType
at (container<KeyType,ValueType> , KeyType) —> ValueType

Result:

the element at the right operand index of the container

Comment:

The first element of the container is located at the index 0. In addition, if the user tries to get the element at an index higher or equals than the length of the container, he will get an IndexOutOfBoundException.The at operator behavior depends on the nature of the operand

Special cases:

if it is a file, at returns the element of the file content at the index specified by the right operand
if it is a population, at returns the agent at the index specified by the right operand
if it is a graph and if the right operand is a node, at returns the in and out edges corresponding to that node
if it is a graph and if the right operand is an edge, at returns the pair node_out::node_in of the edge
if it is a graph and if the right operand is a pair node1::node2, at returns the edge from node1 to node2 in the graph
if it is a list or a matrix, at returns the element at the index specified by the right operand

int var1 <- [1, 2, 3] at 2; 	// var1 equals 3
point var2 <- [{1,2}, {3,4}, {5,6}] at 0; 	// var2 equals {1.0,2.0}

Examples:

string var0 <- 'abcdef' at 0; 	// var0 equals 'a'

`at_distance`

Possible use:

container<agent> at_distance float —> list<geometry>
at_distance (container<agent> , float) —> list<geometry>

Result:

A list of agents or geometries among the left-operand list that are located at a distance <= the right operand from the caller agent (in its topology)

Examples:

list<geometry> var0 <- [ag1, ag2, ag3] at_distance 20; 	// var0 equals the agents of the list located at a distance <= 20 from the caller agent (in the same order).

`at_location`

Possible use:

geometry at_location point —> geometry
at_location (geometry , point) —> geometry

Result:

A geometry resulting from the tran of a translation to the right-hand operand point of the left-hand operand (geometry, agent, point)

Examples:

geometry var0 <- self at_location {10, 20}; 	// var0 equals the geometry resulting from a translation to the location {10, 20} of the left-hand geometry (or agent).

`atan`

Possible use:

atan (float) —> float
atan (int) —> float

Result:

Returns the value (in the interval [-90,90], in decimal degrees) of the arctan of the operand (which can be any real number).

Examples:

float var0 <- atan (1); 	// var0 equals 45.0

`atan2`

Possible use:

float atan2 float —> float
atan2 (float , float) —> float

Result:

the atan2 value of the two operands.

Comment:

The function atan2 is the arctangent function with two arguments. The purpose of using two arguments instead of one is to gather information on the signs of the inputs in order to return the appropriate quadrant of the computed angle, which is not possible for the single-argument arctangent function.

Examples:

float var0 <- atan2 (0,0); 	// var0 equals 0.0

`attributes`

Possible use:

attributes (any) —> attributes

Result:

Casts the operand into the type attributes

`BDIPlan`

Possible use:

BDIPlan (any) —> BDIPlan

Result:

Casts the operand into the type BDIPlan

`before`

Possible use:

before (date) —> bool
any expression before date —> bool
before (any expression , date) —> bool

Result:

Returns true if the current_date of the model is strictly before the date passed in argument. Synonym of ‘current_date < argument’

Examples:

reflex when: before(starting_date) {} -: will never be run

`beta_index`

Possible use:

beta_index (graph) —> float

Result:

returns the beta index of the graph (Measures the level of connectivity in a graph and is expressed by the relationship between the number of links (e) over the number of nodes (v) : beta = e/v.

Examples:

graph graphEpidemio <- graph([]);
float var1 <- beta_index(graphEpidemio); 	// var1 equals the beta index of the graph

`between`

Possible use:

date between date —> bool
between (date , date) —> bool
between (int, int, int) —> bool
between (any expression, date, date) —> bool
between (float, float, float) —> bool
between (date, date, date) —> bool

Result:

returns true the first integer operand is bigger than the second integer operand and smaller than the third integer operand returns true if the first float operand is bigger than the second float operand and smaller than the third float operand

Special cases:

returns true if the first operand is between the two dates passed in arguments (both exclusive). Can be combined with ‘every’ to express a frequency between two dates

(date('2016-01-01') between(date('2000-01-01'), date('2020-02-02') -: true
every #day between(date('2000-01-01'), date('2020-02-02') // will return true every new day between these two dates, taking the first one as the starting point

returns true if the first operand is between the two dates passed in arguments (both exclusive). The version with 2 arguments compares the current_date with the 2 others

(date('2016-01-01') between(date('2000-01-01'), date('2020-02-02') -: true
between(date('2000-01-01'), date('2020-02-02') // will return true if the current_date of the model is in_between the 2

Examples:

bool var0 <- between(5, 1, 10); 	// var0 equals true
bool var1 <- between(5.0, 1.0, 10.0); 	// var1 equals true

`betweenness_centrality`

Possible use:

betweenness_centrality (graph) —> map

Result:

returns a map containing for each vertex (key), its betweenness centrality (value): number of shortest paths passing through each vertex

Examples:

graph graphEpidemio <- graph([]);
map var1 <- betweenness_centrality(graphEpidemio); 	// var1 equals the betweenness centrality index of the graph

`biggest_cliques_of`

Possible use:

biggest_cliques_of (graph) —> list<list>

Result:

returns the biggest cliques of a graph using the Bron-Kerbosch clique detection algorithm

Examples:

graph my_graph <- graph([]);
list<list> var1 <- biggest_cliques_of (my_graph); 	// var1 equals the list of the biggest cliques as list

`binomial`

Possible use:

int binomial float —> int
binomial (int , float) —> int

Result:

A value from a random variable following a binomial distribution. The operands represent the number of experiments n and the success probability p.

Comment:

The binomial distribution is the discrete probability distribution of the number of successes in a sequence of n independent yes/no experiments, each of which yields success with probability p, cf. Binomial distribution on Wikipedia.

Examples:

int var0 <- binomial(15,0.6); 	// var0 equals a random positive integer

`blend`

Possible use:

rgb blend rgb —> rgb
blend (rgb , rgb) —> rgb
blend (rgb, rgb, float) —> rgb

Result:

Blend two colors with an optional ratio (c1 * r + c2 * (1 - r)) between 0 and 1

Special cases:

If the ratio is omitted, an even blend is done

rgb var3 <- blend(#red, #blue); 	// var3 equals to a color very close to the purple

Examples:

rgb var1 <- blend(#red, #blue, 0.3); 	// var1 equals to a color between the purple and the blue

`bool`

Possible use:

bool (any) —> bool

Result:

Casts the operand into the type bool

`box`

Possible use:

box (point) —> geometry
box (float, float, float) —> geometry

Result:

A box geometry which side sizes are given by the operands.

Comment:

the center of the box is by default the location of the current agent in which has been called this operator.the center of the box is by default the location of the current agent in which has been called this operator.

Special cases:

returns nil if the operand is nil.
returns nil if the operand is nil.

Examples:

geometry var0 <- box(10, 5 , 5); 	// var0 equals a geometry as a rectangle with width = 10, height = 5 depth= 5.
geometry var1 <- box({10, 5 , 5}); 	// var1 equals a geometry as a rectangle with width = 10, height = 5 depth= 5.

`brewer_colors`

Possible use:

brewer_colors (string) —> list<rgb>
string brewer_colors int —> list<rgb>
brewer_colors (string , int) —> list<rgb>

Result:

Build a list of colors of a given type (see website http://colorbrewer2.org/) Build a list of colors of a given type (see website http://colorbrewer2.org/) with a given number of classes

Examples:

list<rgb> var0 <- list<rgb> colors <- brewer_colors("OrRd");; 	// var0 equals a list of 6 blue colors
list<rgb> var1 <- list<rgb> colors <- brewer_colors("Pastel1", 10);; 	// var1 equals a list of 10 sequential colors

`brewer_palettes`

Possible use:

brewer_palettes (int) —> list<string>
int brewer_palettes int —> list<string>
brewer_palettes (int , int) —> list<string>

Result:

returns the list a palette with a given min number of classes and max number of classes) returns the list a palette with a given min number of classes and max number of classes)

Examples:

list<string> var0 <- list<rgb> colors <- brewer_palettes(5,10);; 	// var0 equals a list of palettes that are composed of a min of 5 colors and a max of 10 colors
list<string> var1 <- list<rgb> colors <- brewer_palettes();; 	// var1 equals a list of palettes that are composed of a min of 5 colors

`buffer`

Same signification as +

`build`

Possible use:

build (matrix<float>) —> regression
matrix<float> build string —> regression
build (matrix<float> , string) —> regression

Result:

returns the regression build from the matrix data (a row = an instance, the last value of each line is the y value) while using the given ordinary least squares method. Usage: build(data) returns the regression build from the matrix data (a row = an instance, the last value of each line is the y value) while using the given method (“GLS” or “OLS”). Usage: build(data,method)

Examples:

matrix([[1,2,3,4],[2,3,4,2]])
build(matrix([[1,2,3,4],[2,3,4,2]]),"GLS")

`ceil`

Possible use:

ceil (float) —> float

Result:

Maps the operand to the smallest following integer, i.e. the smallest integer not less than x.

Examples:

float var0 <- ceil(3); 	// var0 equals 3.0
float var1 <- ceil(3.5); 	// var1 equals 4.0
float var2 <- ceil(-4.7); 	// var2 equals -4.0

`centroid`

Possible use:

centroid (geometry) —> point

Result:

Centroid (weighted sum of the centroids of a decomposition of the area into triangles) of the operand-geometry. Can be different to the location of the geometry

Examples:

point var0 <- centroid(world); 	// var0 equals the centroid of the square, for example : {50.0,50.0}.

`char`

Possible use:

char (int) —> string

Special cases:

converts ACSII integer value to character

string var0 <- char (34); 	// var0 equals '"'

`circle`

Possible use:

circle (float) —> geometry
float circle point —> geometry
circle (float , point) —> geometry

Result:

A circle geometry which radius is equal to the first operand, and the center has the location equal to the second operand. A circle geometry which radius is equal to the operand.

Comment:

the center of the circle is by default the location of the current agent in which has been called this operator.

Special cases:

returns a point if the operand is lower or equal to 0.
returns a point if the operand is lower or equal to 0.

Examples:

geometry var0 <- circle(10,{80,30}); 	// var0 equals a geometry as a circle of radius 10, the center will be in the location {80,30}.
geometry var1 <- circle(10); 	// var1 equals a geometry as a circle of radius 10.

`clean`

Possible use:

clean (geometry) —> geometry

Result:

A geometry corresponding to the cleaning of the operand (geometry, agent, point)

Comment:

The cleaning corresponds to a buffer with a distance of 0.0

Examples:

geometry var0 <- clean(self); 	// var0 equals returns the geometry resulting from the cleaning of the geometry of the agent applying the operator.

`closest_points_with`

Possible use:

geometry closest_points_with geometry —> list<point>
closest_points_with (geometry , geometry) —> list<point>

Result:

A list of two closest points between the two geometries.

Examples:

list<point> var0 <- geom1 closest_points_with(geom2); 	// var0 equals [pt1, pt2] with pt1 the closest point of geom1 to geom2 and pt1 the closest point of geom2 to geom1

`closest_to`

Possible use:

container<agent> closest_to geometry —> geometry
closest_to (container<agent> , geometry) —> geometry

Result:

An agent or a geometry among the left-operand list of agents, species or meta-population (addition of species), the closest to the operand (casted as a geometry).

Comment:

the distance is computed in the topology of the calling agent (the agent in which this operator is used), with the distance algorithm specific to the topology.

Examples:

geometry var0 <- [ag1, ag2, ag3] closest_to(self); 	// var0 equals return the closest agent among ag1, ag2 and ag3 to the agent applying the operator.
(species1 + species2) closest_to self

`collect`

Possible use:

container collect any expression —> container
collect (container , any expression) —> container

Result:

returns a new list, in which each element is the evaluation of the right-hand operand.

Comment:

collect is similar to accumulate except that accumulate always produces flat lists if the right-hand operand returns a list.In addition, collect can be applied to any container.

Special cases:

if the left-hand operand is nil, collect throws an error

Examples:

container var0 <- [1,2,4] collect (each *2); 	// var0 equals [2,4,8]
container var1 <- [1,2,4] collect ([2,4]); 	// var1 equals [[2,4],[2,4],[2,4]]
container var2 <- [1::2, 3::4, 5::6] collect (each + 2); 	// var2 equals [4,6,8]
container var3 <- (list(node) collect (node(each).location.x * 2); 	// var3 equals the list of nodes with their x multiplied by 2

`column_at`

Possible use:

matrix column_at int —> list
column_at (matrix , int) —> list

Result:

returns the column at a num_col (right-hand operand)

Examples:

list var0 <- matrix([["el11","el12","el13"],["el21","el22","el23"],["el31","el32","el33"]]) column_at 2; 	// var0 equals ["el31","el32","el33"]

`columns_list`

Possible use:

columns_list (matrix) —> list<list>

Result:

returns a list of the columns of the matrix, with each column as a list of elements

Examples:

list<list> var0 <- columns_list(matrix([["el11","el12","el13"],["el21","el22","el23"],["el31","el32","el33"]])); 	// var0 equals [["el11","el12","el13"],["el21","el22","el23"],["el31","el32","el33"]]

`command`

Possible use:

command (string) —> string

Result:

command allows GAMA to issue a system command using the system terminal or shell and to receive a string containing the outcome of the command or script executed. By default, commands are blocking the agent calling them, unless the sequence ‘ &’ is used at the end. In this case, the result of the operator is an empty string

`cone`

Possible use:

cone (point) —> geometry
int cone int —> geometry
cone (int , int) —> geometry

Result:

A cone geometry which min and max angles are given by the operands. A cone geometry which min and max angles are given by the operands.

Comment:

the center of the cone is by default the location of the current agent in which has been called this operator.the center of the cone is by default the location of the current agent in which has been called this operator.

Special cases:

returns nil if the operand is nil.
returns nil if the operand is nil.

Examples:

geometry var0 <- cone({0, 45}); 	// var0 equals a geometry as a cone with min angle is 0 and max angle is 45.
geometry var1 <- cone(0, 45); 	// var1 equals a geometry as a cone with min angle is 0 and max angle is 45.

`cone3D`

Possible use:

float cone3D float —> geometry
cone3D (float , float) —> geometry

Result:

A cone geometry which base radius size is equal to the first operand, and which the height is equal to the second operand.

Comment:

the center of the cone is by default the location of the current agent in which has been called this operator.

Special cases:

returns a point if the operand is lower or equal to 0.

Examples:

geometry var0 <- cone3D(10.0,5.0); 	// var0 equals a geometry as a cone with a base circle of radius 10 and a height of 5.

`connected_components_of`

Possible use:

connected_components_of (graph) —> list<list>

Result:

returns the connected components of of a graph, i.e. the list of all vertices that are in the maximally connected component together with the specified vertex.

Examples:

graph my_graph <- graph([]);
list<list> var1 <- connected_components_of (my_graph); 	// var1 equals the list of all the components as list

`connectivity_index`

Possible use:

connectivity_index (graph) —> float

Result:

returns a simple connectivity index. This number is estimated through the number of nodes (v) and of sub-graphs (p) : IC = (v - p) /(v - 1).

Examples:

graph graphEpidemio <- graph([]);
float var1 <- connectivity_index(graphEpidemio); 	// var1 equals the connectivity index of the graph

`container`

Possible use:

container (any) —> container

Result:

Casts the operand into the type container

`contains`

Possible use:

container<KeyType,ValueType> contains unknown —> bool
contains (container<KeyType,ValueType> , unknown) —> bool
string contains string —> bool
contains (string , string) —> bool

Result:

true, if the container contains the right operand, false otherwise

Comment:

the contains operator behavior depends on the nature of the operand

Special cases:

if it is a map, contains returns true if the operand is a key of the map
if it is a file, contains returns true it the operand is contained in the file content
if it is a population, contains returns true if the operand is an agent of the population, false otherwise
if it is a graph, contains returns true if the operand is a node or an edge of the graph, false otherwise
if both operands are strings, returns true if the right-hand operand contains the right-hand pattern;
if it is a list or a matrix, contains returns true if the list or matrix contains the right operand

bool var0 <- [1, 2, 3] contains 2; 	// var0 equals true
bool var1 <- [{1,2}, {3,4}, {5,6}] contains {3,4}; 	// var1 equals true

Examples:

bool var2 <- 'abcded' contains 'bc'; 	// var2 equals true

`contains_all`

Possible use:

container contains_all container —> bool
contains_all (container , container) —> bool
string contains_all list —> bool
contains_all (string , list) —> bool

Result:

true if the left operand contains all the elements of the right operand, false otherwise

Comment:

the definition of contains depends on the container

Special cases:

if the right operand is nil or empty, contains_all returns true
if the left-operand is a string, test whether the string contains all the element of the list;

bool var4 <- "abcabcabc" contains_all ["ca","xy"]; 	// var4 equals false

Examples:

bool var0 <- [1,2,3,4,5,6] contains_all [2,4]; 	// var0 equals true 
bool var1 <- [1,2,3,4,5,6] contains_all [2,8]; 	// var1 equals false
bool var2 <- [1::2, 3::4, 5::6] contains_all [1,3]; 	// var2 equals false 
bool var3 <- [1::2, 3::4, 5::6] contains_all [2,4]; 	// var3 equals true

`contains_any`

Possible use:

container contains_any container —> bool
contains_any (container , container) —> bool
string contains_any list —> bool
contains_any (string , list) —> bool

Result:

true if the left operand contains one of the elements of the right operand, false otherwise

Comment:

the definition of contains depends on the container

Special cases:

if the right operand is nil or empty, contains_any returns false

Examples:

bool var0 <- [1,2,3,4,5,6] contains_any [2,4]; 	// var0 equals true 
bool var1 <- [1,2,3,4,5,6] contains_any [2,8]; 	// var1 equals true
bool var2 <- [1::2, 3::4, 5::6] contains_any [1,3]; 	// var2 equals false
bool var3 <- [1::2, 3::4, 5::6] contains_any [2,4]; 	// var3 equals true
bool var4 <- "abcabcabc" contains_any ["ca","xy"]; 	// var4 equals true

`contains_edge`

Possible use:

graph contains_edge unknown —> bool
contains_edge (graph , unknown) —> bool
graph contains_edge pair —> bool
contains_edge (graph , pair) —> bool

Result:

returns true if the graph(left-hand operand) contains the given edge (righ-hand operand), false otherwise

Special cases:

if the left-hand operand is nil, returns false
if the right-hand operand is a pair, returns true if it exists an edge between the two elements of the pair in the graph

bool var2 <- graphEpidemio contains_edge (node(0)::node(3)); 	// var2 equals true

Examples:

graph graphFromMap <-  as_edge_graph([{1,5}::{12,45},{12,45}::{34,56}]);
bool var1 <- graphFromMap contains_edge link({1,5}::{12,45}); 	// var1 equals true

`contains_vertex`

Possible use:

graph contains_vertex unknown —> bool
contains_vertex (graph , unknown) —> bool

Result:

returns true if the graph(left-hand operand) contains the given vertex (righ-hand operand), false otherwise

Special cases:

if the left-hand operand is nil, returns false

Examples:

graph graphFromMap<-  as_edge_graph([{1,5}::{12,45},{12,45}::{34,56}]);
bool var1 <- graphFromMap contains_vertex {1,5}; 	// var1 equals true

`conversation`

Possible use:

conversation (unknown) —> conversation

`convex_hull`

Possible use:

convex_hull (geometry) —> geometry

Result:

A geometry corresponding to the convex hull of the operand.

Examples:

geometry var0 <- convex_hull(self); 	// var0 equals the convex hull of the geometry of the agent applying the operator

`copy`

Possible use:

copy (unknown) —> unknown

Result:

returns a copy of the operand.

`copy_between`

Possible use:

copy_between (string, int, int) —> string
copy_between (container, int, int) —> container

Result:

Returns a copy of the first operand between the indexes determined by the second (inclusive) and third operands (exclusive)

Special cases:

If the first operand is empty, returns an empty object of the same type
If the second operand is greater than or equal to the third operand, return an empty object of the same type
If the first operand is nil, raises an error

Examples:

string var0 <- copy_between("abcabcabc", 2,6); 	// var0 equals "cabc"
container var1 <-  copy_between ([4, 1, 6, 9 ,7], 1, 3); 	// var1 equals [1, 6]

`corR`

Possible use:

container corR container —> unknown
corR (container , container) —> unknown

Result:

returns the Pearson correlation coefficient of two given vectors (right-hand operands) in given variable (left-hand operand).

Special cases:

if the lengths of two vectors in the right-hand aren’t equal, returns 0

Examples:

list X <- [1, 2, 3];
list Y <- [1, 2, 4];
unknown var2 <- corR(X, Y); 	// var2 equals 0.981980506061966

`cos`

Possible use:

cos (int) —> float
cos (float) —> float

Result:

Returns the value (in [-1,1]) of the cosinus of the operand (in decimal degrees). The argument is casted to an int before being evaluated.

Special cases:

Operand values out of the range [0-359] are normalized.

Examples:

float var0 <- cos (0); 	// var0 equals 1.0
float var1 <- cos(360); 	// var1 equals 1.0
float var2 <- cos(-720); 	// var2 equals 1.0

`cos_rad`

Possible use:

cos_rad (float) —> float

Result:

Returns the value (in [-1,1]) of the cosinus of the operand (in decimal degrees). The argument is casted to an int before being evaluated.

Special cases:

Operand values out of the range [0-359] are normalized.

`count`

Possible use:

container count any expression —> int
count (container , any expression) —> int

Result:

returns an int, equal to the number of elements of the left-hand operand that make the right-hand operand evaluate to true.

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the elements.

Special cases:

if the left-hand operand is nil, count throws an error

Examples:

int var0 <- [1,2,3,4,5,6,7,8] count (each > 3); 	// var0 equals 5
// Number of nodes of graph g2 without any out edge
graph g2 <- graph([]);
int var3 <- g2 count (length(g2 out_edges_of each) = 0  ) ; 	// var3 equals the total number of out edges
// Number of agents node with x > 32
int n <- (list(node) count (round(node(each).location.x) > 32);
int var6 <- [1::2, 3::4, 5::6] count (each > 4); 	// var6 equals 1

`covers`

Possible use:

geometry covers geometry —> bool
covers (geometry , geometry) —> bool

Result:

A boolean, equal to true if the left-geometry (or agent/point) covers the right-geometry (or agent/point).

Special cases:

if one of the operand is null, returns false.

Examples:

bool var0 <- square(5) covers square(2); 	// var0 equals true

`cross`

Possible use:

cross (float) —> geometry
float cross float —> geometry
cross (float , float) —> geometry

Result:

A cross, which radius is equal to the first operand A cross, which radius is equal to the first operand and the width of the lines for the second

Examples:

geometry var0 <- cross(10); 	// var0 equals a geometry as a cross of radius 10
geometry var1 <- cross(10,2); 	// var1 equals a geometry as a cross of radius 10, and with a width of 2 for the lines

`crosses`

Possible use:

geometry crosses geometry —> bool
crosses (geometry , geometry) —> bool

Result:

A boolean, equal to true if the left-geometry (or agent/point) crosses the right-geometry (or agent/point).

Special cases:

if one of the operand is null, returns false.
if one operand is a point, returns false.

Examples:

bool var0 <- polyline([{10,10},{20,20}]) crosses polyline([{10,20},{20,10}]); 	// var0 equals true
bool var1 <- polyline([{10,10},{20,20}]) crosses {15,15}; 	// var1 equals true
bool var2 <- polyline([{0,0},{25,25}]) crosses polygon([{10,10},{10,20},{20,20},{20,10}]); 	// var2 equals true

`crs`

Possible use:

crs (file) —> string

Result:

the Coordinate Reference System (CRS) of the GIS file

Examples:

string var0 <- crs(my_shapefile); 	// var0 equals the crs of the shapefile

`CRS_transform`

Possible use:

CRS_transform (geometry) —> geometry
geometry CRS_transform string —> geometry
CRS_transform (geometry , string) —> geometry

Special cases:

returns the geometry corresponding to the transformation of the given geometry by the left operand CRS (Coordinate Reference System)

geometry var0 <- shape CRS_transform("EPSG:4326"); 	// var0 equals a geometry corresponding to the agent geometry transformed into the EPSG:4326 CRS

returns the geometry corresponding to the transformation of the given geometry by the current CRS (Coordinate Reference System), the one corresponding to the world’s agent one

geometry var1 <- CRS_transform(shape); 	// var1 equals a geometry corresponding to the agent geometry transformed into the current CRS

`csv_file`

Possible use:

csv_file (string) —> file

Result:

Constructs a file of type csv. Allowed extensions are limited to csv, tsv

`cube`

Possible use:

cube (float) —> geometry

Result:

A cube geometry which side size is equal to the operand.

Comment:

the center of the cube is by default the location of the current agent in which has been called this operator.

Special cases:

returns nil if the operand is nil.

Examples:

geometry var0 <- cube(10); 	// var0 equals a geometry as a square of side size 10.

`curve`

Possible use:

curve (point, point, point) —> geometry
curve (point, point, point, int) —> geometry
curve (point, point, point, point) —> geometry
curve (point, point, point, point, int) —> geometry

Result:

A quadratic Bezier curve geometry built from the three given points composed of a given numnber of points. A quadratic Bezier curve geometry built from the three given points composed of 10 points. A cubic Bezier curve geometry built from the four given points composed of a given number of points. A cubic Bezier curve geometry built from the four given points composed of 10 points.

Special cases:

if the operand is nil, returns nil
if the last operand (number of points) is inferior to 2, returns nil
if the operand is nil, returns nil
if the operand is nil, returns nil
if the last operand (number of points) is inferior to 2, returns nil
if the operand is nil, returns nil

Examples:

geometry var0 <- curve({0,0}, {0,10}, {10,10}, 20); 	// var0 equals a quadratic Bezier curve geometry composed of 20 points from p0 to p2.
geometry var1 <- curve({0,0}, {0,10}, {10,10}); 	// var1 equals a quadratic Bezier curve geometry composed of 10 points from p0 to p2.
geometry var2 <- curve({0,0}, {0,10}, {10,10}); 	// var2 equals a cubic Bezier curve geometry composed of 10 points from p0 to p3.
geometry var3 <- curve({0,0}, {0,10}, {10,10}); 	// var3 equals a cubic Bezier curve geometry composed of 10 points from p0 to p3.

`cylinder`

Possible use:

float cylinder float —> geometry
cylinder (float , float) —> geometry

Result:

A cylinder geometry which radius is equal to the operand.

Comment:

the center of the cylinder is by default the location of the current agent in which has been called this operator.

Special cases:

returns a point if the operand is lower or equal to 0.

Examples:

geometry var0 <- cylinder(10,10); 	// var0 equals a geometry as a circle of radius 10.

`date`

Possible use:

string date string —> date
date (string , string) —> date

Result:

converts a string to a date following a custom pattern. The pattern can use “%Y %M %N %D %E %h %m %s %z” for outputting years, months, name of month, days, name of days, hours, minutes, seconds and the time-zone. A null or empty pattern will parse the date using one of the ISO date & time formats (similar to date(‘…’) in that case). The pattern can also follow the pattern definition found here, which gives much more control over what will be parsed: https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html#patterns. Different patterns are available by default as constant: #iso_local, #iso_simple, #iso_offset, #iso_zoned and #custom, which can be changed in the preferences

Examples:

date("1999-12-30", 'yyyy-MM-dd')

`dbscan`

Possible use:

dbscan (list, float, int) —> list<list>

Result:

returns the list of clusters (list of instance indices) computed with the dbscan (density-based spatial clustering of applications with noise) algorithm from the first operand data according to the maximum radius of the neighborhood to be considered (eps) and the minimum number of points needed for a cluster (minPts). Usage: dbscan(data,eps,minPoints)

Special cases:

if the lengths of two vectors in the right-hand aren’t equal, returns 0

Examples:

dbscan ([[2,4,5], [3,8,2], [1,1,3], [4,3,4]],10,2)

`dead`

Possible use:

dead (agent) —> bool

Result:

true if the agent is dead (or null), false otherwise.

Examples:

bool var0 <- dead(agent_A); 	// var0 equals true or false

`degree_of`

Possible use:

graph degree_of unknown —> int
degree_of (graph , unknown) —> int

Result:

returns the degree (in+out) of a vertex (right-hand operand) in the graph given as left-hand operand.

Examples:

int var1 <- graphFromMap degree_of (node(3)); 	// var1 equals 3

`dem`

Possible use:

dem (file) —> geometry
file dem file —> geometry
dem (file , file) —> geometry
file dem float —> geometry
dem (file , float) —> geometry
dem (file, file, float) —> geometry

Result:

A polygon that is equivalent to the surface of the texture

Examples:

geometry var0 <- dem(dem,texture,z_factor); 	// var0 equals a geometry as a rectangle of width and height equal to the texture.
geometry var1 <- dem(dem,texture); 	// var1 equals a geometry as a rectangle of weight and height equal to the texture.
geometry var2 <- dem(dem,z_factor); 	// var2 equals a geometry as a rectangle of weight and height equal to the texture.
geometry var3 <- dem(dem); 	// var3 equals returns a geometry as a rectangle of width and height equal to the texture.

`det`

Same signification as determinant

`determinant`

Possible use:

determinant (matrix) —> float

Result:

The determinant of the given matrix

Examples:

float var0 <- determinant(matrix([[1,2],[3,4]])); 	// var0 equals -2

`diff`

Possible use:

float diff float —> float
diff (float , float) —> float

`diff2`

Possible use:

float diff2 float —> float
diff2 (float , float) —> float

`directed`

Possible use:

directed (graph) —> graph

Result:

the operand graph becomes a directed graph.

Comment:

the operator alters the operand graph, it does not create a new one.

`direction_between`

Possible use:

topology direction_between container<geometry> —> int
direction_between (topology , container<geometry>) —> int

Result:

A direction (in degree) between a list of two geometries (geometries, agents, points) considering a topology.

Examples:

int var0 <- my_topology direction_between [ag1, ag2]; 	// var0 equals the direction between ag1 and ag2 considering the topology my_topology

`direction_to`

Same signification as towards

`disjoint_from`

Possible use:

geometry disjoint_from geometry —> bool
disjoint_from (geometry , geometry) —> bool

Result:

A boolean, equal to true if the left-geometry (or agent/point) is disjoints from the right-geometry (or agent/point).

Special cases:

if one of the operand is null, returns true.
if one operand is a point, returns false if the point is included in the geometry.

Examples:

bool var0 <- polyline([{10,10},{20,20}]) disjoint_from polyline([{15,15},{25,25}]); 	// var0 equals false
bool var1 <- polygon([{10,10},{10,20},{20,20},{20,10}]) disjoint_from polygon([{15,15},{15,25},{25,25},{25,15}]); 	// var1 equals false
bool var2 <- polygon([{10,10},{10,20},{20,20},{20,10}]) disjoint_from {15,15}; 	// var2 equals false
bool var3 <- polygon([{10,10},{10,20},{20,20},{20,10}]) disjoint_from {25,25}; 	// var3 equals true
bool var4 <- polygon([{10,10},{10,20},{20,20},{20,10}]) disjoint_from polygon([{35,35},{35,45},{45,45},{45,35}]); 	// var4 equals true

`distance_between`

Possible use:

topology distance_between container<geometry> —> float
distance_between (topology , container<geometry>) —> float

Result:

A distance between a list of geometries (geometries, agents, points) considering a topology.

Examples:

float var0 <- my_topology distance_between [ag1, ag2, ag3]; 	// var0 equals the distance between ag1, ag2 and ag3 considering the topology my_topology

`distance_to`

Possible use:

geometry distance_to geometry —> float
distance_to (geometry , geometry) —> float
point distance_to point —> float
distance_to (point , point) —> float

Result:

A distance between two geometries (geometries, agents or points) considering the topology of the agent applying the operator.

Examples:

float var0 <- ag1 distance_to ag2; 	// var0 equals the distance between ag1 and ag2 considering the topology of the agent applying the operator

`distinct`

Possible use:

distinct (container) —> container

Result:

produces a set from the elements of the operand (i.e. a list without duplicated elements)

Special cases:

if the operand is nil, remove_duplicates returns nil
if the operand is a graph, remove_duplicates returns the set of nodes
if the operand is a matrix, remove_duplicates returns a matrix without duplicated row
if the operand is a map, remove_duplicates returns the set of values without duplicate

container var1 <- remove_duplicates([1::3,2::4,3::3,5::7]); 	// var1 equals [3,4,7]

Examples:

container var0 <- remove_duplicates([3,2,5,1,2,3,5,5,5]); 	// var0 equals [3,2,5,1]

`distribution_of`

Possible use:

distribution_of (container) —> map
container distribution_of int —> map
distribution_of (container , int) —> map
distribution_of (container, int, float, float) —> map

Result:

Discretize a list of values into n bins (computes the bins from a numerical variable into n (default 10) bins. Returns a distribution map with the values (values key), the interval legends (legend key), the distribution parameters (params keys, for cumulative charts). Parameters can be (list), (list, nbbins) or (list,nbbins,valmin,valmax)

Examples:

map var0 <- distribution_of([1,1,2,12.5]); 	// var0 equals map(['values'::[2,1,0,0,0,0,1,0,0,0],'legend'::['[0.0:2.0]','[2.0:4.0]','[4.0:6.0]','[6.0:8.0]','[8.0:10.0]','[10.0:12.0]','[12.0:14.0]','[14.0:16.0]','[16.0:18.0]','[18.0:20.0]'],'parlist'::[1,0]])
map var1 <- distribution_of([1,1,2,12.5],10); 	// var1 equals map(['values'::[2,1,0,0,0,0,1,0,0,0],'legend'::['[0.0:2.0]','[2.0:4.0]','[4.0:6.0]','[6.0:8.0]','[8.0:10.0]','[10.0:12.0]','[12.0:14.0]','[14.0:16.0]','[16.0:18.0]','[18.0:20.0]'],'parlist'::[1,0]])
map var2 <- distribution_of([1,1,2,12.5]); 	// var2 equals map(['values'::[2,1,0,0,0,0,1,0,0,0],'legend'::['[0.0:2.0]','[2.0:4.0]','[4.0:6.0]','[6.0:8.0]','[8.0:10.0]','[10.0:12.0]','[12.0:14.0]','[14.0:16.0]','[16.0:18.0]','[18.0:20.0]'],'parlist'::[1,0]])

`distribution2d_of`

Possible use:

container distribution2d_of container —> map
distribution2d_of (container , container) —> map
distribution2d_of (container, container, int, int) —> map
distribution2d_of (container, container, int, float, float, int, float, float) —> map

Result:

Discretize two lists of values into n bins (computes the bins from a numerical variable into n (default 10) bins. Returns a distribution map with the values (values key), the interval legends (legend key), the distribution parameters (params keys, for cumulative charts). Parameters can be (list), (list, nbbins) or (list,nbbins,valmin,valmax)

Examples:

map var0 <- distribution_of([1,1,2,12.5],10); 	// var0 equals map(['values'::[2,1,0,0,0,0,1,0,0,0],'legend'::['[0.0:2.0]','[2.0:4.0]','[4.0:6.0]','[6.0:8.0]','[8.0:10.0]','[10.0:12.0]','[12.0:14.0]','[14.0:16.0]','[16.0:18.0]','[18.0:20.0]'],'parlist'::[1,0]])
map var1 <- distribution2d_of([1,1,2,12.5]); 	// var1 equals map(['values'::[2,1,0,0,0,0,1,0,0,0],'legend'::['[0.0:2.0]','[2.0:4.0]','[4.0:6.0]','[6.0:8.0]','[8.0:10.0]','[10.0:12.0]','[12.0:14.0]','[14.0:16.0]','[16.0:18.0]','[18.0:20.0]'],'parlist'::[1,0]])
map var2 <- distribution_of([1,1,2,12.5],10); 	// var2 equals map(['values'::[2,1,0,0,0,0,1,0,0,0],'legend'::['[0.0:2.0]','[2.0:4.0]','[4.0:6.0]','[6.0:8.0]','[8.0:10.0]','[10.0:12.0]','[12.0:14.0]','[14.0:16.0]','[16.0:18.0]','[18.0:20.0]'],'parlist'::[1,0]])

`div`

Possible use:

float div float —> int
div (float , float) —> int
int div int —> int
div (int , int) —> int
float div int —> int
div (float , int) —> int
int div float —> int
div (int , float) —> int

Result:

Returns the truncation of the division of the left-hand operand by the right-hand operand.

Special cases:

if the right-hand operand is equal to zero, raises an exception.
if the right-hand operand is equal to zero, raises an exception.
if the right-hand operand is equal to zero, raises an exception.

Examples:

int var0 <- 40.1 div 4.5; 	// var0 equals 8
int var1 <- 40 div 3; 	// var1 equals 13
int var2 <- 40.5 div 3; 	// var2 equals 13
int var3 <- 40 div 4.1; 	// var3 equals 9

`dxf_file`

Possible use:

dxf_file (string) —> file

Result:

Constructs a file of type dxf. Allowed extensions are limited to dxf

`edge`

Possible use:

edge (pair) —> unknown
edge (unknown) —> unknown
unknown edge unknown —> unknown
edge (unknown , unknown) —> unknown
pair edge float —> unknown
edge (pair , float) —> unknown
unknown edge float —> unknown
edge (unknown , float) —> unknown
edge (unknown, unknown, unknown) —> unknown
edge (unknown, unknown, float) —> unknown
edge (pair, unknown, float) —> unknown
edge (unknown, unknown, unknown, float) —> unknown

`edge_between`

Possible use:

graph edge_between pair —> unknown
edge_between (graph , pair) —> unknown

Result:

returns the edge linking two nodes

Examples:

unknown var0 <- graphFromMap edge_between node1::node2; 	// var0 equals edge1

`edge_betweenness`

Possible use:

edge_betweenness (graph) —> map

Result:

returns a map containing for each edge (key), its betweenness centrality (value): number of shortest paths passing through each edge

Examples:

graph graphEpidemio <- graph([]);
map var1 <- edge_betweenness(graphEpidemio); 	// var1 equals the edge betweenness index of the graph

`edges`

Possible use:

edges (container) —> container

`eigenvalues`

Possible use:

eigenvalues (matrix) —> list<float>

Result:

The eigen values (matrix) of the given matrix

Examples:

list<float> var0 <- eigenvalues(matrix([[5,-3],[6,-4]])); 	// var0 equals [2.0000000000000004,-0.9999999999999998]

`electre_DM`

Possible use:

electre_DM (list<list>, list<map<string,object>>, float) —> int

Result:

The index of the best candidate according to a method based on the ELECTRE methods. The principle of the ELECTRE methods is to compare the possible candidates by pair. These methods analyses the possible outranking relation existing between two candidates. An candidate outranks another if this one is at least as good as the other one. The ELECTRE methods are based on two concepts: the concordance and the discordance. The concordance characterizes the fact that, for an outranking relation to be validated, a sufficient majority of criteria should be in favor of this assertion. The discordance characterizes the fact that, for an outranking relation to be validated, none of the criteria in the minority should oppose too strongly this assertion. These two conditions must be true for validating the outranking assertion. More information about the ELECTRE methods can be found in [http://www.springerlink.com/content/g367r44322876223/ Figueira, J., Mousseau, V., Roy, B.: ELECTRE Methods. In: Figueira, J., Greco, S., and Ehrgott, M., (Eds.), Multiple Criteria Decision Analysis: State of the Art Surveys, Springer, New York, 133–162 (2005)]. The first operand is the list of candidates (a candidate is a list of criterion values); the second operand the list of criterion: A criterion is a map that contains fives elements: a name, a weight, a preference value (p), an indifference value (q) and a veto value (v). The preference value represents the threshold from which the difference between two criterion values allows to prefer one vector of values over another. The indifference value represents the threshold from which the difference between two criterion values is considered significant. The veto value represents the threshold from which the difference between two criterion values disqualifies the candidate that obtained the smaller value; the last operand is the fuzzy cut.

Special cases:

returns -1 is the list of candidates is nil or empty

Examples:

int var0 <- electre_DM([[1.0, 7.0],[4.0,2.0],[3.0, 3.0]], [["name"::"utility", "weight" :: 2.0,"p"::0.5, "q"::0.0, "s"::1.0, "maximize" :: true],["name"::"price", "weight" :: 1.0,"p"::0.5, "q"::0.0, "s"::1.0, "maximize" :: false]]); 	// var0 equals 0

`ellipse`

Possible use:

float ellipse float —> geometry
ellipse (float , float) —> geometry

Result:

An ellipse geometry which x-radius is equal to the first operand and y-radius is equal to the second operand

Comment:

the center of the ellipse is by default the location of the current agent in which has been called this operator.

Special cases:

returns a point if both operands are lower or equal to 0, a line if only one is.

Examples:

geometry var0 <- ellipse(10, 10); 	// var0 equals a geometry as an ellipse of width 10 and height 10.

`emotion`

Possible use:

emotion (any) —> emotion

Result:

Casts the operand into the type emotion

`empty`

Possible use:

empty (container<KeyType,ValueType>) —> bool
empty (string) —> bool

Result:

true if the operand is empty, false otherwise.

Comment:

the empty operator behavior depends on the nature of the operand

Special cases:

if it is a map, empty returns true if the map contains no key-value mappings, and false otherwise
if it is a file, empty returns true if the content of the file (that is also a container) is empty, and false otherwise
if it is a population, empty returns true if there is no agent in the population, and false otherwise
if it is a graph, empty returns true if it contains no vertex and no edge, and false otherwise
if it is a matrix of int, float or object, it will return true if all elements are respectively 0, 0.0 or null, and false otherwise
if it is a matrix of geometry, it will return true if the matrix contains no cell, and false otherwise
if it is a list, empty returns true if there is no element in the list, and false otherwise

bool var0 <- empty([]); 	// var0 equals true

if it is a string, empty returns true if the string does not contain any character, and false otherwise

bool var1 <- empty ('abced'); 	// var1 equals false

`enlarged_by`

Same signification as +

`envelope`

Possible use:

envelope (unknown) —> geometry

Result:

A 3D geometry that represents the box that surrounds the geometries or the surface described by the arguments. More general than geometry(arguments).envelope, as it allows to pass int, double, point, image files, shape files, asc files, or any list combining these arguments, in which case the envelope will be correctly expanded. If an envelope cannot be determined from the arguments, a default one of dimensions (0,100, 0, 100, 0, 100) is returned

`eval_gaml`

Possible use:

eval_gaml (string) —> unknown

Result:

evaluates the given GAML string.

Examples:

unknown var0 <- eval_gaml("2+3"); 	// var0 equals 5

`eval_when`

Possible use:

eval_when (BDIPlan) —> bool

Result:

evaluate the facet when of a given plan

Examples:

eval_when(plan1)

`even`

Possible use:

even (int) —> bool

Result:

Returns true if the operand is even and false if it is odd.

Special cases:

if the operand is equal to 0, it returns true.
if the operand is a float, it is truncated before

Examples:

bool var0 <- even (3); 	// var0 equals false
bool var1 <- even(-12); 	// var1 equals true

`every`

Possible use:

every (int) —> bool
every (any expression) —> bool
msi.gama.util.GamaDateInterval every any expression —> msi.gama.util.IList<msi.gama.util.GamaDate>
every (msi.gama.util.GamaDateInterval , any expression) —> msi.gama.util.IList<msi.gama.util.GamaDate>
container every int —> container
every (container , int) —> container

Result:

true every operand * cycle, false otherwise applies a step to an interval of dates defined by ‘date1 to date2’ expects a frequency (expressed in seconds of simulated time) as argument. Will return true every time the current_date matches with this frequency Retrieves elements from the first argument every step (second argument) elements. Raises an error if the step is negative or equal to zero

Comment:

the value of the every operator depends on the cycle. It can be used to do something every x cycle.Used to do something at regular intervals of time. Can be used in conjunction with ‘since’, ‘after’, ‘before’, ‘until’ or ‘between’, so that this computation only takes place in the temporal segment defined by these operators. In all cases, the starting_date of the model is used as a reference starting point

Examples:

if every(2) {write "the cycle number is even";}
	     else {write "the cycle number is odd";}
(date('2000-01-01') to date('2010-01-01')) every (#month) // builds an interval between these two dates which contains all the monthly dates starting from the beginning of the interval
reflex when: every(2#days) since date('2000-01-01') { .. }
state a { transition to: b when: every(2#mn);} state b { transition to: a when: every(30#s);} // This oscillatory behavior will use the starting_date of the model as its starting point in time

`every_cycle`

Same signification as every

`evidence_theory_DM`

Possible use:

list<list> evidence_theory_DM list<map<string,object>> —> int
evidence_theory_DM (list<list> , list<map<string,object>>) —> int
evidence_theory_DM (list<list>, list<map<string,object>>, bool) —> int

Result:

The index of the best candidate according to a method based on the Evidence theory. This theory, which was proposed by Shafer ([http://www.glennshafer.com/books/amte.html Shafer G (1976) A mathematical theory of evidence, Princeton University Press]), is based on the work of Dempster ([http://projecteuclid.org/DPubS?service=UI&version=1.0&verb=Display&handle=euclid.aoms/1177698950 Dempster A (1967) Upper and lower probabilities induced by multivalued mapping. Annals of Mathematical Statistics, vol. 38, pp. 325–339]) on lower and upper probability distributions. The first operand is the list of candidates (a candidate is a list of criterion values); the second operand the list of criterion: A criterion is a map that contains seven elements: a name, a first threshold s1, a second threshold s2, a value for the assertion “this candidate is the best” at threshold s1 (v1p), a value for the assertion “this candidate is the best” at threshold s2 (v2p), a value for the assertion “this candidate is not the best” at threshold s1 (v1c), a value for the assertion “this candidate is not the best” at threshold s2 (v2c). v1p, v2p, v1c and v2c have to been defined in order that: v1p + v1c <= 1.0; v2p + v2c <= 1.0.; the last operand allows to use a simple version of this multi-criteria decision making method (simple if true)

Special cases:

if the operator is used with only 2 operands (the candidates and the criteria), the last parameter (use simple method) is set to true
returns -1 is the list of candidates is nil or empty

Examples:

int var0 <- evidence_theory_DM([[1.0, 7.0],[4.0,2.0],[3.0, 3.0]], [["name"::"utility", "s1" :: 0.0,"s2"::1.0, "v1p"::0.0, "v2p"::1.0, "v1c"::0.0, "v2c"::0.0, "maximize" :: true],["name"::"price",  "s1" :: 0.0,"s2"::1.0, "v1p"::0.0, "v2p"::1.0, "v1c"::0.0, "v2c"::0.0, "maximize" :: true]], true); 	// var0 equals 0

`exp`

Possible use:

exp (float) —> float
exp (int) —> float

Result:

Returns Euler’s number e raised to the power of the operand.

Special cases:

the operand is casted to a float before being evaluated.
the operand is casted to a float before being evaluated.

Examples:

float var0 <- exp (0); 	// var0 equals 1.0

`fact`

Possible use:

fact (int) —> float

Result:

Returns the factorial of the operand.

Special cases:

if the operand is less than 0, fact returns 0.

Examples:

float var0 <- fact(4); 	// var0 equals 24

`farthest_point_to`

Possible use:

geometry farthest_point_to point —> point
farthest_point_to (geometry , point) —> point

Result:

the farthest point of the left-operand to the left-point.

Examples:

point var0 <- geom farthest_point_to(pt); 	// var0 equals the farthest point of geom to pt

`farthest_to`

Possible use:

container<agent> farthest_to geometry —> geometry
farthest_to (container<agent> , geometry) —> geometry

Result:

An agent or a geometry among the left-operand list of agents, species or meta-population (addition of species), the farthest to the operand (casted as a geometry).

Comment:

the distance is computed in the topology of the calling agent (the agent in which this operator is used), with the distance algorithm specific to the topology.

Examples:

geometry var0 <- [ag1, ag2, ag3] closest_to(self); 	// var0 equals return the farthest agent among ag1, ag2 and ag3 to the agent applying the operator.
(species1 + species2) closest_to self

`file`

Possible use:

file (string) —> file
string file container —> file
file (string , container) —> file

Result:

opens a file in read only mode, creates a GAML file object, and tries to determine and store the file content in the contents attribute. Creates a file in read/write mode, setting its contents to the container passed in parameter

Comment:

The file should have a supported extension, see file type definition for supported file extensions.The type of container to pass will depend on the type of file (see the management of files in the documentation). Can be used to copy files since files are considered as containers. For example: save file(‘image_copy.png’, file(‘image.png’)); will copy image.png to image_copy.png

Special cases:

If the specified string does not refer to an existing file, an exception is risen when the variable is used.

Examples:

let fileT type: file value: file("../includes/Stupid_Cell.Data"); 
			// fileT represents the file "../includes/Stupid_Cell.Data"
			// fileT.contents here contains a matrix storing all the data of the text file

`file_exists`

Possible use:

file_exists (string) —> bool

Result:

Test whether the parameter is the path to an existing file.

`first`

Possible use:

first (string) —> string
first (container<KeyType,ValueType>) —> ValueType
int first container —> container
first (int , container) —> container

Result:

the first value of the operand

Comment:

the first operator behavior depends on the nature of the operand

Special cases:

if it is a map, first returns the first value of the first pair (in insertion order)
if it is a file, first returns the first element of the content of the file (that is also a container)
if it is a population, first returns the first agent of the population
if it is a graph, first returns the first edge (in creation order)
if it is a matrix, first returns the element at {0,0} in the matrix
for a matrix of int or float, it will return 0 if the matrix is empty
for a matrix of object or geometry, it will return nil if the matrix is empty
if it is a string, first returns a string composed of its first character

string var0 <- first ('abce'); 	// var0 equals 'a'

if it is a list, first returns the first element of the list, or nil if the list is empty

int var1 <- first ([1, 2, 3]); 	// var1 equals 1

`first_of`

Same signification as first

`first_with`

Possible use:

container first_with any expression —> unknown
first_with (container , any expression) —> unknown

Result:

the first element of the left-hand operand that makes the right-hand operand evaluate to true.

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

if the left-hand operand is nil, first_with throws an error. If there is no element that satisfies the condition, it returns nil
if the left-operand is a map, the keyword each will contain each value

unknown var4 <- [1::2, 3::4, 5::6] first_with (each >= 4); 	// var4 equals 4
unknown var5 <- [1::2, 3::4, 5::6].pairs first_with (each.value >= 4); 	// var5 equals 3::4

Examples:

unknown var0 <- [1,2,3,4,5,6,7,8] first_with (each > 3); 	// var0 equals 4
unknown var2 <- g2 first_with (length(g2 out_edges_of each) = 0); 	// var2 equals node9
unknown var3 <- (list(node) first_with (round(node(each).location.x) > 32); 	// var3 equals node2

`flip`

Possible use:

flip (float) —> bool

Result:

true or false given the probability represented by the operand

Special cases:

flip 0 always returns false, flip 1 true

Examples:

bool var0 <- flip (0.66666); 	// var0 equals 2/3 chances to return true.

`float`

Possible use:

float (any) —> float

Result:

Casts the operand into the type float

`floor`

Possible use:

floor (float) —> float

Result:

Maps the operand to the largest previous following integer, i.e. the largest integer not greater than x.

Examples:

float var0 <- floor(3); 	// var0 equals 3.0
float var1 <- floor(3.5); 	// var1 equals 3.0
float var2 <- floor(-4.7); 	// var2 equals -5.0

`folder`

Possible use:

folder (string) —> file

Result:

opens an existing repository

Special cases:

If the specified string does not refer to an existing repository, an exception is risen.

Examples:

folder("../includes/")
file dirT <- folder("../includes/");
				// dirT represents the repository "../includes/"
				// dirT.contents here contains the list of the names of included files

`font`

Possible use:

font (string, int, int) —> font

Result:

Creates a new font, by specifying its name (either a font face name like ‘Lucida Grande Bold’ or ‘Helvetica’, or a logical name like ‘Dialog’, ‘SansSerif’, ‘Serif’, etc.), a size in points and a style, either #bold, #italic or #plain or a combination (addition) of them.

Examples:

font var0 <- font ('Helvetica Neue',12, #bold + #italic); 	// var0 equals a bold and italic face of the Helvetica Neue family

`frequency_of`

Possible use:

container frequency_of any expression —> map
frequency_of (container , any expression) —> map

Result:

Returns a map with keys equal to the application of the right-hand argument (like collect) and values equal to the frequency of this key (i.e. how many times it has been obtained)

Examples:

map var0 <- [ag1, ag2, ag3, ag4] frequency_of each.size; 	// var0 equals the different sizes as keys and the number of agents of this size as values

`from`

Same signification as since

`fuzzy_kappa`

Possible use:

fuzzy_kappa (list<agent>, list, list, list<float>, list, matrix<float>, float) —> float
fuzzy_kappa (list<agent>, list, list, list<float>, list, matrix<float>, float, list) —> float

Result:

fuzzy kappa indicator for 2 map comparisons: fuzzy_kappa(agents_list,list_vals1,list_vals2, output_similarity_per_agents,categories,fuzzy_categories_matrix, fuzzy_distance, weights). Reference: Visser, H., and T. de Nijs, 2006. The map comparison kit, Environmental Modelling & Software, 21 fuzzy kappa indicator for 2 map comparisons: fuzzy_kappa(agents_list,list_vals1,list_vals2, output_similarity_per_agents,categories,fuzzy_categories_matrix, fuzzy_distance). Reference: Visser, H., and T. de Nijs, 2006. The map comparison kit, Environmental Modelling & Software, 21

Examples:

fuzzy_kappa([ag1, ag2, ag3, ag4, ag5],[cat1,cat1,cat2,cat3,cat2],[cat2,cat1,cat2,cat1,cat2], similarity_per_agents,[cat1,cat2,cat3],[[1,0,0],[0,1,0],[0,0,1]], 2, [1.0,3.0,2.0,2.0,4.0])
fuzzy_kappa([ag1, ag2, ag3, ag4, ag5],[cat1,cat1,cat2,cat3,cat2],[cat2,cat1,cat2,cat1,cat2], similarity_per_agents,[cat1,cat2,cat3],[[1,0,0],[0,1,0],[0,0,1]], 2)

`fuzzy_kappa_sim`

Possible use:

fuzzy_kappa_sim (list<agent>, list, list, list, list<float>, list, matrix<float>, float) —> float
fuzzy_kappa_sim (list<agent>, list, list, list, list<float>, list, matrix<float>, float, list) —> float

Result:

fuzzy kappa simulation indicator for 2 map comparisons: fuzzy_kappa_sim(agents_list,list_vals1,list_vals2, output_similarity_per_agents,fuzzy_transitions_matrix, fuzzy_distance). Reference: Jasper van Vliet, Alex Hagen-Zanker, Jelle Hurkens, Hedwig van Delden, A fuzzy set approach to assess the predictive accuracy of land use simulations, Ecological Modelling, 24 July 2013, Pages 32-42, ISSN 0304-3800, fuzzy kappa simulation indicator for 2 map comparisons: fuzzy_kappa_sim(agents_list,list_vals1,list_vals2, output_similarity_per_agents,fuzzy_transitions_matrix, fuzzy_distance, weights). Reference: Jasper van Vliet, Alex Hagen-Zanker, Jelle Hurkens, Hedwig van Delden, A fuzzy set approach to assess the predictive accuracy of land use simulations, Ecological Modelling, 24 July 2013, Pages 32-42, ISSN 0304-3800,

Examples:

fuzzy_kappa_sim([ag1, ag2, ag3, ag4, ag5], [cat1,cat1,cat2,cat3,cat2],[cat2,cat1,cat2,cat1,cat2], similarity_per_agents,[cat1,cat2,cat3],[[1,0,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0,0],[0,0,0,0,0,1,0,0,0],[0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,0,1]], 2)
fuzzy_kappa_sim([ag1, ag2, ag3, ag4, ag5], [cat1,cat1,cat2,cat3,cat2],[cat2,cat1,cat2,cat1,cat2], similarity_per_agents,[cat1,cat2,cat3],[[1,0,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0,0],[0,0,0,0,0,1,0,0,0],[0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,0,1]], 2,[1.0,3.0,2.0,2.0,4.0])

`gaml_file`

Possible use:

gaml_file (string) —> file

Result:

Constructs a file of type gaml. Allowed extensions are limited to gaml, experiment

`gamma_index`

Possible use:

gamma_index (graph) —> float

Result:

returns the gamma index of the graph (A measure of connectivity that considers the relationship between the number of observed links and the number of possible links: gamma = e/(3 * (v - 2)) - for planar graph.

Examples:

graph graphEpidemio <- graph([]);
float var1 <- gamma_index(graphEpidemio); 	// var1 equals the gamma index of the graph

`gamma_rnd`

Possible use:

float gamma_rnd float —> float
gamma_rnd (float , float) —> float

Result:

returns a random value from a gamma distribution with specified values of the shape and scale parameters

Examples:

gamma_rnd(10.0,5.0)

`gauss`

Possible use:

gauss (point) —> float
float gauss float —> float
gauss (float , float) —> float

Result:

A value from a normally distributed random variable with expected value (mean) and variance (standardDeviation). The probability density function of such a variable is a Gaussian. A value from a normally distributed random variable with expected value (mean) and variance (standardDeviation). The probability density function of such a variable is a Gaussian.

Special cases:

when the operand is a point, it is read as {mean, standardDeviation}
when standardDeviation value is 0.0, it always returns the mean value
when the operand is a point, it is read as {mean, standardDeviation}
when standardDeviation value is 0.0, it always returns the mean value

Examples:

float var0 <- gauss(0,0.3); 	// var0 equals 0.22354
float var1 <- gauss(0,0.3); 	// var1 equals -0.1357
float var2 <- gauss({0,0.3}); 	// var2 equals 0.22354
float var3 <- gauss({0,0.3}); 	// var3 equals -0.1357

`generate_barabasi_albert`

Possible use:

generate_barabasi_albert (container<agent>, species, int, bool) —> graph
generate_barabasi_albert (species, species, int, int, bool) —> graph

Result:

returns a random scale-free network (following Barabasi-Albert (BA) model). returns a random scale-free network (following Barabasi-Albert (BA) model).

Comment:

The Barabasi-Albert (BA) model is an algorithm for generating random scale-free networks using a preferential attachment mechanism. A scale-free network is a network whose degree distribution follows a power law, at least asymptotically.Such networks are widely observed in natural and human-made systems, including the Internet, the world wide web, citation networks, and some social networks. [From Wikipedia article]The map operand should includes following elements:The Barabasi-Albert (BA) model is an algorithm for generating random scale-free networks using a preferential attachment mechanism. A scale-free network is a network whose degree distribution follows a power law, at least asymptotically.Such networks are widely observed in natural and human-made systems, including the Internet, the world wide web, citation networks, and some social networks. [From Wikipedia article]The map operand should includes following elements:

Special cases:

“vertices_specy”: the species of vertices
“edges_species”: the species of edges
“size”: the graph will contain (size + 1) nodes
“m”: the number of edges added per novel node
“synchronized”: is the graph and the species of vertices and edges synchronized?
“agents”: list of existing node agents
“edges_species”: the species of edges
“size”: the graph will contain (size + 1) nodes
“m”: the number of edges added per novel node
“synchronized”: is the graph and the species of vertices and edges synchronized?

Examples:

graph<yourNodeSpecy,yourEdgeSpecy> graphEpidemio <- generate_barabasi_albert(
		yourNodeSpecy,
		yourEdgeSpecy,
		3,
		5,
		true);
graph<yourNodeSpecy,yourEdgeSpecy> graphEpidemio <- generate_barabasi_albert(
		yourListOfNodes,
		yourEdgeSpecy,
		3,
		5,
		true);

`generate_complete_graph`

Possible use:

generate_complete_graph (container<agent>, species, bool) —> graph
generate_complete_graph (container<agent>, species, float, bool) —> graph
generate_complete_graph (species, species, int, bool) —> graph
generate_complete_graph (species, species, int, float, bool) —> graph

Result:

returns a fully connected graph. returns a fully connected graph. returns a fully connected graph. returns a fully connected graph.

Comment:

Arguments should include following elements:Arguments should include following elements:Arguments should include following elements:Arguments should include following elements:

Special cases:

“agents”: list of existing node agents
“edges_species”: the species of edges
“layoutRadius”: nodes of the graph will be located on a circle with radius layoutRadius and centered in the environment.
“synchronized”: is the graph and the species of vertices and edges synchronized?
“vertices_specy”: the species of vertices
“edges_species”: the species of edges
“size”: the graph will contain size nodes.
“layoutRadius”: nodes of the graph will be located on a circle with radius layoutRadius and centered in the environment.
“synchronized”: is the graph and the species of vertices and edges synchronized?
“vertices_specy”: the species of vertices
“edges_species”: the species of edges
“size”: the graph will contain size nodes.
“synchronized”: is the graph and the species of vertices and edges synchronized?
“agents”: list of existing node agents
“edges_species”: the species of edges
“synchronized”: is the graph and the species of vertices and edges synchronized?

Examples:

graph<myVertexSpecy,myEdgeSpecy> myGraph <- generate_complete_graph(
			myListOfNodes,
			myEdgeSpecy,
			25,
		true);
graph<myVertexSpecy,myEdgeSpecy> myGraph <- generate_complete_graph(
			myVertexSpecy,
			myEdgeSpecy,
			10, 25,
		true);
graph<myVertexSpecy,myEdgeSpecy> myGraph <- generate_complete_graph(
			myVertexSpecy,
			myEdgeSpecy,
			10,
		true);
graph<myVertexSpecy,myEdgeSpecy> myGraph <- generate_complete_graph(
			myListOfNodes,
			myEdgeSpecy,
		true);

`generate_watts_strogatz`

Possible use:

generate_watts_strogatz (container<agent>, species, float, int, bool) —> graph
generate_watts_strogatz (species, species, int, float, int, bool) —> graph

Result:

returns a random small-world network (following Watts-Strogatz model). returns a random small-world network (following Watts-Strogatz model).

Comment:

The Watts-Strogatz model is a random graph generation model that produces graphs with small-world properties, including short average path lengths and high clustering.A small-world network is a type of graph in which most nodes are not neighbors of one another, but most nodes can be reached from every other by a small number of hops or steps. [From Wikipedia article]The map operand should includes following elements:The Watts-Strogatz model is a random graph generation model that produces graphs with small-world properties, including short average path lengths and high clustering.A small-world network is a type of graph in which most nodes are not neighbors of one another, but most nodes can be reached from every other by a small number of hops or steps. [From Wikipedia article]The map operand should includes following elements:

Special cases:

“vertices_specy”: the species of vertices
“edges_species”: the species of edges
“size”: the graph will contain (size + 1) nodes. Size must be greater than k.
“p”: probability to “rewire” an edge. So it must be between 0 and 1. The parameter is often called beta in the literature.
“k”: the base degree of each node. k must be greater than 2 and even.
“synchronized”: is the graph and the species of vertices and edges synchronized?
“agents”: list of existing node agents
“edges_species”: the species of edges
“p”: probability to “rewire” an edge. So it must be between 0 and 1. The parameter is often called beta in the literature.
“k”: the base degree of each node. k must be greater than 2 and even.
“synchronized”: is the graph and the species of vertices and edges synchronized?

Examples:

graph<myVertexSpecy,myEdgeSpecy> myGraph <- generate_watts_strogatz(
			myVertexSpecy,
			myEdgeSpecy,
			2,
			0.3,
			2,
		true);
graph<myVertexSpecy,myEdgeSpecy> myGraph <- generate_watts_strogatz(
			myListOfNodes,
			myEdgeSpecy,
			0.3,
			2,
		true);

`geojson_file`

Possible use:

geojson_file (string) —> file

Result:

Constructs a file of type geojson. Allowed extensions are limited to json, geojson, geo.json

`geometric_mean`

Possible use:

geometric_mean (container) —> float

Result:

the geometric mean of the elements of the operand. See Geometric_mean for more details.

Comment:

The operator casts all the numerical element of the list into float. The elements that are not numerical are discarded.

Examples:

float var0 <- geometric_mean ([4.5, 3.5, 5.5, 7.0]); 	// var0 equals 4.962326343467649

`geometry`

Possible use:

geometry (any) —> geometry

Result:

Casts the operand into the type geometry

`geometry_collection`

Possible use:

geometry_collection (container<geometry>) —> geometry

Result:

A geometry collection (multi-geometry) composed of the given list of geometries.

Special cases:

if the operand is nil, returns the point geometry {0,0}
if the operand is composed of a single geometry, returns a copy of the geometry.

Examples:

geometry var0 <- geometry_collection([{0,0}, {0,10}, {10,10}, {10,0}]); 	// var0 equals a geometry composed of the 4 points (multi-point).

`get`

Possible use:

geometry get string —> unknown
get (geometry , string) —> unknown
agent get string —> unknown
get (agent , string) —> unknown

Result:

Reads an attribute of the specified geometry (left operand). The attribute name is specified by the right operand. Reads an attribute of the specified agent (left operand). The attribute name is specified by the right operand.

Special cases:

Reading the attribute of a geometry

string geom_area <- a_geometry get('area');     // reads then 'area' attribute of 'a_geometry' variable then assigns the returned value to the geom_area variable

Reading the attribute of another agent

string agent_name <- an_agent get('name');     // reads then 'name' attribute of an_agent then assigns the returned value to the agent_name variable

`get_about`

Possible use:

get_about (emotion) —> predicate

Result:

get the about value of the given emotion

Examples:

get_about(emotion)

`get_agent`

Possible use:

get_agent (msi.gaml.architecture.simplebdi.SocialLink) —> agent

Result:

get the agent value of the given social link

Examples:

get_agent(social_link1)

`get_agent_cause`

Possible use:

get_agent_cause (emotion) —> agent
get_agent_cause (predicate) —> agent

Result:

get the agent cause value of the given emotion

Examples:

get_agent_cause(emotion)

`get_decay`

Possible use:

get_decay (emotion) —> float

Result:

get the decay value of the given emotion

Examples:

get_decay(emotion)

`get_dominance`

Possible use:

get_dominance (msi.gaml.architecture.simplebdi.SocialLink) —> float

Result:

get the dominance value of the given social link

Examples:

get_dominance(social_link1)

`get_familiarity`

Possible use:

get_familiarity (msi.gaml.architecture.simplebdi.SocialLink) —> float

Result:

get the familiarity value of the given social link

Examples:

get_familiarity(social_link1)

`get_intensity`

Possible use:

get_intensity (emotion) —> float

Result:

get the intensity value of the given emotion

Examples:

emotion set_intensity 12

`get_lifetime`

Possible use:

get_lifetime (predicate) —> int

`get_liking`

Possible use:

get_liking (msi.gaml.architecture.simplebdi.SocialLink) —> float

Result:

get the liking value of the given social link

Examples:

get_liking(social_link1)

`get_praiseworthiness`

Possible use:

get_praiseworthiness (predicate) —> float

`get_priority`

Possible use:

get_priority (predicate) —> float

`get_solidarity`

Possible use:

get_solidarity (msi.gaml.architecture.simplebdi.SocialLink) —> float

Result:

get the solidarity value of the given social link

Examples:

get_solidarity(social_link1)

`get_super_intention`

Possible use:

get_super_intention (predicate) —> predicate

`gif_file`

Possible use:

gif_file (string) —> file

Result:

Constructs a file of type gif. Allowed extensions are limited to gif

`gini`

Possible use:

gini (list<float>) —> float

Special cases:

return the Gini Index of the given list of values (list of floats)

float var0 <- gini([1.0, 0.5, 2.0]); 	// var0 equals the gini index computed

`graph`

Possible use:

graph (any) —> graph

Result:

Casts the operand into the type graph

`grayscale`

Possible use:

grayscale (rgb) —> rgb

Result:

Converts rgb color to grayscale value

Comment:

r=red, g=green, b=blue. Between 0 and 255 and gray = 0.299 * red + 0.587 * green + 0.114 * blue (Photoshop value)

Examples:

rgb var0 <- grayscale (rgb(255,0,0)); 	// var0 equals to a dark grey

`grid_at`

Possible use:

species grid_at point —> agent
grid_at (species , point) —> agent

Result:

returns the cell of the grid (right-hand operand) at the position given by the right-hand operand

Comment:

If the left-hand operand is a point of floats, it is used as a point of ints.

Special cases:

if the left-hand operand is not a grid cell species, returns nil

Examples:

agent var0 <- grid_cell grid_at {1,2}; 	// var0 equals the agent grid_cell with grid_x=1 and grid_y = 2

`grid_cells_to_graph`

Possible use:

grid_cells_to_graph (container) —> graph

Result:

creates a graph from a list of cells (operand). An edge is created between neighbors.

Examples:

my_cell_graph<-grid_cells_to_graph(cells_list)

`grid_file`

Possible use:

grid_file (string) —> file

Result:

Constructs a file of type grid. Allowed extensions are limited to asc, tif

`group_by`

Possible use:

container group_by any expression —> map
group_by (container , any expression) —> map

Result:

Returns a map, where the keys take the possible values of the right-hand operand and the map values are the list of elements of the left-hand operand associated to the key value

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

if the left-hand operand is nil, group_by throws an error

Examples:

map var0 <- [1,2,3,4,5,6,7,8] group_by (each > 3); 	// var0 equals [false::[1, 2, 3], true::[4, 5, 6, 7, 8]]
map var1 <- g2 group_by (length(g2 out_edges_of each) ); 	// var1 equals [ 0::[node9, node7, node10, node8, node11], 1::[node6], 2::[node5], 3::[node4]]
map var2 <- (list(node) group_by (round(node(each).location.x)); 	// var2 equals [32::[node5], 21::[node1], 4::[node0], 66::[node2], 96::[node3]]
map var3 <- [1::2, 3::4, 5::6] group_by (each > 4); 	// var3 equals [false::[2, 4], true::[6]]

`harmonic_mean`

Possible use:

harmonic_mean (container) —> float

Result:

the harmonic mean of the elements of the operand. See Harmonic_mean for more details.

Comment:

The operator casts all the numerical element of the list into float. The elements that are not numerical are discarded.

Examples:

float var0 <- harmonic_mean ([4.5, 3.5, 5.5, 7.0]); 	// var0 equals 4.804159445407279

`hexagon`

Possible use:

hexagon (point) —> geometry
hexagon (float) —> geometry

Result:

A hexagon geometry which the given with and height

Comment:

the center of the hexagon is by default the location of the current agent in which has been called this operator.the center of the hexagon is by default the location of the current agent in which has been called this operator.

Special cases:

returns nil if the operand is nil.
returns nil if the operand is nil.

Examples:

geometry var0 <- hexagon({10,5}); 	// var0 equals a geometry as a hexagon of width of 10 and height of 5.
geometry var1 <- hexagon(10); 	// var1 equals a geometry as a hexagon of width of 10 and height of 10.

`hierarchical_clustering`

Possible use:

container<agent> hierarchical_clustering float —> container
hierarchical_clustering (container<agent> , float) —> container

Result:

A tree (list of list) contained groups of agents clustered by distance considering a distance min between two groups.

Comment:

use of hierarchical clustering with Minimum for linkage criterion between two groups of agents.

Examples:

container var0 <- [ag1, ag2, ag3, ag4, ag5] hierarchical_clustering 20.0; 	// var0 equals for example, can return [[[ag1],[ag3]], [ag2], [[[ag4],[ag5]],[ag6]]

`hsb`

Possible use:

hsb (float, float, float) —> rgb
hsb (float, float, float, int) —> rgb
hsb (float, float, float, float) —> rgb

Result:

Converts hsb (h=hue, s=saturation, b=brightness) value to Gama color

Comment:

h,s and b components should be floating-point values between 0.0 and 1.0 and when used alpha should be an integer (between 0 and 255) or a float (between 0 and 1) . Examples: Red=(0.0,1.0,1.0), Yellow=(0.16,1.0,1.0), Green=(0.33,1.0,1.0), Cyan=(0.5,1.0,1.0), Blue=(0.66,1.0,1.0), Magenta=(0.83,1.0,1.0)

Examples:

rgb var0 <- hsb (0.5,1.0,1.0,0.0); 	// var0 equals rgb("cyan",0)
rgb var1 <- hsb (0.0,1.0,1.0); 	// var1 equals rgb("red")

`hypot`

Possible use:

hypot (float, float, float, float) —> float

Result:

Returns sqrt(x2 +y2) without intermediate overflow or underflow.

Special cases:

If either argument is infinite, then the result is positive infinity. If either argument is NaN and neither argument is infinite, then the result is NaN.

Examples:

float var0 <- hypot(0,1,0,1); 	// var0 equals sqrt(2)

`IDW`

Possible use:

IDW (container<agent>, map<point,float>, int) —> map<agent,float>

Result:

Inverse Distance Weighting (IDW) is a type of deterministic method for multivariate interpolation with a known scattered set of points. The assigned values to each geometry are calculated with a weighted average of the values available at the known points. See: http://en.wikipedia.org/wiki/Inverse_distance_weighting Usage: IDW (list of geometries, map of points (key: point, value: value), power parameter)

Examples:

map<agent,float> var0 <- IDW([ag1, ag2, ag3, ag4, ag5],[{10,10}::25.0, {10,80}::10.0, {100,10}::15.0], 2); 	// var0 equals for example, can return [ag1::12.0, ag2::23.0,ag3::12.0,ag4::14.0,ag5::17.0]

`image_file`

Possible use:

image_file (string) —> file

Result:

Constructs a file of type image. Allowed extensions are limited to tiff, jpg, jpeg, png, pict, bmp

`in`

Possible use:

unknown in container —> bool
in (unknown , container) —> bool
string in string —> bool
in (string , string) —> bool

Result:

true if the right operand contains the left operand, false otherwise

Comment:

the definition of in depends on the container

Special cases:

if the right operand is nil or empty, in returns false
if both operands are strings, returns true if the left-hand operand patterns is included in to the right-hand string;

Examples:

bool var0 <- 2 in [1,2,3,4,5,6]; 	// var0 equals true
bool var1 <- 7 in [1,2,3,4,5,6]; 	// var1 equals false
bool var2 <- 3 in [1::2, 3::4, 5::6]; 	// var2 equals false
bool var3 <- 6 in [1::2, 3::4, 5::6]; 	// var3 equals true
bool var4 <-  'bc' in 'abcded'; 	// var4 equals true

`in_degree_of`

Possible use:

graph in_degree_of unknown —> int
in_degree_of (graph , unknown) —> int

Result:

returns the in degree of a vertex (right-hand operand) in the graph given as left-hand operand.

Examples:

int var1 <- graphFromMap in_degree_of (node(3)); 	// var1 equals 2

`in_edges_of`

Possible use:

graph in_edges_of unknown —> container
in_edges_of (graph , unknown) —> container

Result:

returns the list of the in-edges of a vertex (right-hand operand) in the graph given as left-hand operand.

Examples:

container var1 <- graphFromMap in_edges_of node({12,45}); 	// var1 equals [LineString]

`indented_by`

Possible use:

string indented_by int —> string
indented_by (string , int) —> string

Result:

Converts a (possibly multiline) string by indenting it by a number – specified by the second operand – of tabulations to the right

`index_by`

Possible use:

container index_by any expression —> map
index_by (container , any expression) —> map

Result:

produces a new map from the evaluation of the right-hand operand for each element of the left-hand operand

Special cases:

if the left-hand operand is nil, index_by throws an error. If the operation results in duplicate keys, only the first value corresponding to the key is kept

Examples:

map var0 <- [1,2,3,4,5,6,7,8] index_by (each - 1); 	// var0 equals [0::1, 1::2, 2::3, 3::4, 4::5, 5::6, 6::7, 7::8]

`index_of`

Possible use:

container index_of unknown —> int
index_of (container , unknown) —> int
map index_of unknown —> unknown
index_of (map , unknown) —> unknown
matrix index_of unknown —> point
index_of (matrix , unknown) —> point
string index_of string —> int
index_of (string , string) —> int
species index_of unknown —> int
index_of (species , unknown) —> int

Result:

the index of the first occurence of the right operand in the left operand container the index of the first occurence of the right operand in the left operand container

Comment:

The definition of index_of and the type of the index depend on the container

Special cases:

if the left operand is a map, index_of returns the index of a value or nil if the value is not mapped
if the left operator is a species, returns the index of an agent in a species. If the argument is not an agent of this species, returns -1. Use int(agent) instead
if the left operand is a list, index_of returns the index as an integer

int var1 <- [1,2,3,4,5,6] index_of 4; 	// var1 equals 3
int var2 <- [4,2,3,4,5,4] index_of 4; 	// var2 equals 0

if the left operand is a matrix, index_of returns the index as a point

point var3 <- matrix([[1,2,3],[4,5,6]]) index_of 4; 	// var3 equals {1.0,0.0}

if both operands are strings, returns the index within the left-hand string of the first occurrence of the given right-hand string

int var4 <-  "abcabcabc" index_of "ca"; 	// var4 equals 2

Examples:

unknown var0 <- [1::2, 3::4, 5::6] index_of 4; 	// var0 equals 3

`inside`

Possible use:

container<agent> inside geometry —> list<geometry>
inside (container<agent> , geometry) —> list<geometry>

Result:

A list of agents or geometries among the left-operand list, species or meta-population (addition of species), covered by the operand (casted as a geometry).

Examples:

list<geometry> var0 <- [ag1, ag2, ag3] inside(self); 	// var0 equals the agents among ag1, ag2 and ag3 that are covered by the shape of the right-hand argument.
list<geometry> var1 <- (species1 + species2) inside (self); 	// var1 equals the agents among species species1 and species2 that are covered by the shape of the right-hand argument.

`int`

Possible use:

int (any) —> int

Result:

Casts the operand into the type int

`inter`

Possible use:

container inter container —> container
inter (container , container) —> container
geometry inter geometry —> geometry
inter (geometry , geometry) —> geometry

Result:

the intersection of the two operands A geometry resulting from the intersection between the two geometries

Comment:

both containers are transformed into sets (so without duplicated element, cf. remove_deplicates operator) before the set intersection is computed.

Special cases:

if an operand is a graph, it will be transformed into the set of its nodes
returns nil if one of the operands is nil
if an operand is a map, it will be transformed into the set of its values

container var0 <- [1::2, 3::4, 5::6] inter [2,4]; 	// var0 equals [2,4]
container var1 <- [1::2, 3::4, 5::6] inter [1,3]; 	// var1 equals []

if an operand is a matrix, it will be transformed into the set of the lines

container var2 <- matrix([[1,2,3],[4,5,4]]) inter [3,4]; 	// var2 equals [3,4]

Examples:

container var3 <- [1,2,3,4,5,6] inter [2,4]; 	// var3 equals [2,4]
container var4 <- [1,2,3,4,5,6] inter [0,8]; 	// var4 equals []
geometry var5 <- square(10) inter circle(5); 	// var5 equals circle(5)

`interleave`

Possible use:

interleave (container) —> container

Result:

a new list containing the interleaved elements of the containers contained in the operand

Comment:

the operand should be a list of lists of elements. The result is a list of elements.

Examples:

container var0 <- interleave([1,2,4,3,5,7,6,8]); 	// var0 equals [1,2,4,3,5,7,6,8]
container var1 <- interleave([['e11','e12','e13'],['e21','e22','e23'],['e31','e32','e33']]); 	// var1 equals ['e11','e21','e31','e12','e22','e32','e13','e23','e33']

`internal_at`

Possible use:

agent internal_at container —> unknown
internal_at (agent , container) —> unknown
geometry internal_at container —> unknown
internal_at (geometry , container) —> unknown
container<KeyType,ValueType> internal_at list<KeyType> —> ValueType
internal_at (container<KeyType,ValueType> , list<KeyType>) —> ValueType

Result:

For internal use only. Corresponds to the implementation, for agents, of the access to containers with [index] For internal use only. Corresponds to the implementation, for geometries, of the access to containers with [index] For internal use only. Corresponds to the implementation of the access to containers with [index]

`internal_integrated_value`

Possible use:

any expression internal_integrated_value any expression —> container
internal_integrated_value (any expression , any expression) —> container

Result:

For internal use only. Corresponds to the implementation, for agents, of the access to containers with [index]

`internal_zero_order_equation`

Possible use:

internal_zero_order_equation (any expression) —> float

`intersection`

Same signification as inter

`intersects`

Possible use:

geometry intersects geometry —> bool
intersects (geometry , geometry) —> bool

Result:

A boolean, equal to true if the left-geometry (or agent/point) intersects the right-geometry (or agent/point).

Special cases:

if one of the operand is null, returns false.

Examples:

bool var0 <- square(5) intersects {10,10}; 	// var0 equals false

`inverse`

Possible use:

inverse (matrix) —> matrix<float>

Result:

The inverse matrix of the given matrix. If no inverse exists, returns a matrix that has properties that resemble that of an inverse.

Examples:

matrix<float> var0 <- inverse(matrix([[5,-3],[6,-4]])); 	// var0 equals [2.0000000000000004,-0.9999999999999998]

`inverse_distance_weighting`

Same signification as IDW

`is`

Possible use:

unknown is any expression —> bool
is (unknown , any expression) —> bool

Result:

returns true if the left operand is of the right operand type, false otherwise

Examples:

bool var0 <- 0 is int; 	// var0 equals true
bool var1 <- an_agent is node; 	// var1 equals true
bool var2 <- 1 is float; 	// var2 equals false

`is_csv`

Possible use:

is_csv (any) —> bool

Result:

Tests whether the operand is a csv file.

`is_dxf`

Possible use:

is_dxf (any) —> bool

Result:

Tests whether the operand is a dxf file.

`is_finite`

Possible use:

is_finite (float) —> bool

Result:

Returns whether the argument is a finite number or not

Examples:

bool var0 <- is_finite(4.66); 	// var0 equals true
bool var1 <- is_finite(#infinity); 	// var1 equals false

`is_gaml`

Possible use:

is_gaml (any) —> bool

Result:

Tests whether the operand is a gaml file.

`is_geojson`

Possible use:

is_geojson (any) —> bool

Result:

Tests whether the operand is a geojson file.

`is_gif`

Possible use:

is_gif (any) —> bool

Result:

Tests whether the operand is a gif file.

`is_grid`

Possible use:

is_grid (any) —> bool

Result:

Tests whether the operand is a grid file.

`is_image`

Possible use:

is_image (any) —> bool

Result:

Tests whether the operand is a image file.

`is_json`

Possible use:

is_json (any) —> bool

Result:

Tests whether the operand is a json file.

`is_number`

Possible use:

is_number (string) —> bool
is_number (float) —> bool

Result:

tests whether the operand represents a numerical value Returns whether the argument is a real number or not

Comment:

Note that the symbol . should be used for a float value (a string with , will not be considered as a numeric value). Symbols e and E are also accepted. A hexadecimal value should begin with #.

Examples:

bool var0 <- is_number("test"); 	// var0 equals false
bool var1 <- is_number("123.56"); 	// var1 equals true
bool var2 <- is_number("-1.2e5"); 	// var2 equals true
bool var3 <- is_number("1,2"); 	// var3 equals false
bool var4 <- is_number("#12FA"); 	// var4 equals true
bool var5 <- is_number(4.66); 	// var5 equals true
bool var6 <- is_number(#infinity); 	// var6 equals true
bool var7 <- is_number(#nan); 	// var7 equals false

`is_obj`

Possible use:

is_obj (any) —> bool

Result:

Tests whether the operand is a obj file.

`is_osm`

Possible use:

is_osm (any) —> bool

Result:

Tests whether the operand is a osm file.

`is_pgm`

Possible use:

is_pgm (any) —> bool

Result:

Tests whether the operand is a pgm file.

`is_property`

Possible use:

is_property (any) —> bool

Result:

Tests whether the operand is a property file.

`is_R`

Possible use:

is_R (any) —> bool

Result:

Tests whether the operand is a R file.

`is_shape`

Possible use:

is_shape (any) —> bool

Result:

Tests whether the operand is a shape file.

`is_skill`

Possible use:

unknown is_skill string —> bool
is_skill (unknown , string) —> bool

Result:

returns true if the left operand is an agent whose species implements the right-hand skill name

Examples:

bool var0 <- agentA is_skill 'moving'; 	// var0 equals true

`is_svg`

Possible use:

is_svg (any) —> bool

Result:

Tests whether the operand is a svg file.

`is_text`

Possible use:

is_text (any) —> bool

Result:

Tests whether the operand is a text file.

`is_threeds`

Possible use:

is_threeds (any) —> bool

Result:

Tests whether the operand is a threeds file.

`is_URL`

Possible use:

is_URL (any) —> bool

Result:

Tests whether the operand is a URL file.

`is_xml`

Possible use:

is_xml (any) —> bool

Result:

Tests whether the operand is a xml file.

`json_file`

Possible use:

json_file (string) —> file

Result:

Constructs a file of type json. Allowed extensions are limited to json

`kappa`

Possible use:

kappa (list, list, list) —> float
kappa (list, list, list, list) —> float

Result:

kappa indicator for 2 map comparisons: kappa(list_vals1,list_vals2,categories). Reference: Cohen, J. A coefficient of agreement for nominal scales. Educ. Psychol. Meas. 1960, 20. kappa indicator for 2 map comparisons: kappa(list_vals1,list_vals2,categories, weights). Reference: Cohen, J. A coefficient of agreement for nominal scales. Educ. Psychol. Meas. 1960, 20.

Examples:

kappa([cat1,cat1,cat2,cat3,cat2],[cat2,cat1,cat2,cat1,cat2],[cat1,cat2,cat3])
float var1 <- kappa([1,3,5,1,5],[1,1,1,1,5],[1,3,5]); 	// var1 equals the similarity between 0 and 1
float var2 <- kappa([1,1,1,1,5],[1,1,1,1,5],[1,3,5]); 	// var2 equals 1.0
kappa([cat1,cat1,cat2,cat3,cat2],[cat2,cat1,cat2,cat1,cat2],[cat1,cat2,cat3], [1.0, 2.0, 3.0, 1.0, 5.0])

`kappa_sim`

Possible use:

kappa_sim (list, list, list, list) —> float
kappa_sim (list, list, list, list, list) —> float

Result:

kappa simulation indicator for 2 map comparisons: kappa(list_valsInits,list_valsObs,list_valsSim, categories). Reference: van Vliet, J., Bregt, A.K. & Hagen-Zanker, A. (2011). Revisiting Kappa to account for change in the accuracy assessment of land-use change models, Ecological Modelling 222(8). kappa simulation indicator for 2 map comparisons: kappa(list_valsInits,list_valsObs,list_valsSim, categories, weights). Reference: van Vliet, J., Bregt, A.K. & Hagen-Zanker, A. (2011). Revisiting Kappa to account for change in the accuracy assessment of land-use change models, Ecological Modelling 222(8)

Examples:

kappa([cat1,cat1,cat2,cat2,cat2],[cat2,cat1,cat2,cat1,cat3],[cat2,cat1,cat2,cat3,cat3], [cat1,cat2,cat3])
kappa([cat1,cat1,cat2,cat2,cat2],[cat2,cat1,cat2,cat1,cat3],[cat2,cat1,cat2,cat3,cat3], [cat1,cat2,cat3],[1.0, 2.0, 3.0, 1.0, 5.0])

`kmeans`

Possible use:

list kmeans int —> list<list>
kmeans (list , int) —> list<list>
kmeans (list, int, int) —> list<list>

Result:

returns the list of clusters (list of instance indices) computed with the kmeans++ algorithm from the first operand data according to the number of clusters to split the data into (k) and the maximum number of iterations to run the algorithm for (If negative, no maximum will be used) (maxIt). Usage: kmeans(data,k,maxit) returns the list of clusters (list of instance indices) computed with the kmeans++ algorithm from the first operand data according to the number of clusters to split the data into (k). Usage: kmeans(data,k)

Special cases:

if the lengths of two vectors in the right-hand aren’t equal, returns 0
if the lengths of two vectors in the right-hand aren’t equal, returns 0

Examples:

kmeans ([[2,4,5], [3,8,2], [1,1,3], [4,3,4]],2,10)
kmeans ([[2,4,5], [3,8,2], [1,1,3], [4,3,4]],2)

`kurtosis`

Possible use:

kurtosis (list) —> float

Result:

returns kurtosis value computed from the operand list of values

Special cases:

if the length of the list is lower than 3, returns NaN

Examples:

kurtosis ([1,2,3,4,5])

`last`

Possible use:

last (string) —> string
last (container<KeyType,ValueType>) —> ValueType
int last container —> container
last (int , container) —> container

Result:

the last element of the operand

Comment:

the last operator behavior depends on the nature of the operand

Special cases:

if it is a map, last returns the value of the last pair (in insertion order)
if it is a file, last returns the last element of the content of the file (that is also a container)
if it is a population, last returns the last agent of the population
if it is a graph, last returns a list containing the last edge created
if it is a matrix, last returns the element at {length-1,length-1} in the matrix
for a matrix of int or float, it will return 0 if the matrix is empty
for a matrix of object or geometry, it will return nil if the matrix is empty
if it is a string, last returns a string composed of its last character, or an empty string if the operand is empty

string var0 <- last ('abce'); 	// var0 equals 'e'

if it is a list, last returns the last element of the list, or nil if the list is empty

int var1 <- last ([1, 2, 3]); 	// var1 equals 3

`last_index_of`

Possible use:

map last_index_of unknown —> unknown
last_index_of (map , unknown) —> unknown
string last_index_of string —> int
last_index_of (string , string) —> int
species last_index_of unknown —> int
last_index_of (species , unknown) —> int
container last_index_of unknown —> int
last_index_of (container , unknown) —> int
matrix last_index_of unknown —> point
last_index_of (matrix , unknown) —> point

Result:

the index of the last occurence of the right operand in the left operand container

Comment:

The definition of last_index_of and the type of the index depend on the container

Special cases:

if the left operand is a species, the last index of an agent is the same as its index
if the left operand is a map, last_index_of returns the index as an int (the key of the pair)

unknown var0 <- [1::2, 3::4, 5::4] last_index_of 4; 	// var0 equals 5

if both operands are strings, returns the index within the left-hand string of the rightmost occurrence of the given right-hand string

int var1 <- "abcabcabc" last_index_of "ca"; 	// var1 equals 5

if the left operand is a list, last_index_of returns the index as an integer

int var2 <- [1,2,3,4,5,6] last_index_of 4; 	// var2 equals 3
int var3 <- [4,2,3,4,5,4] last_index_of 4; 	// var3 equals 5

if the left operand is a matrix, last_index_of returns the index as a point

point var4 <- matrix([[1,2,3],[4,5,4]]) last_index_of 4; 	// var4 equals {1.0,2.0}

`last_of`

Same signification as last

`last_with`

Possible use:

container last_with any expression —> unknown
last_with (container , any expression) —> unknown

Result:

the last element of the left-hand operand that makes the right-hand operand evaluate to true.

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

if the left-hand operand is nil, last_with throws an error.
If there is no element that satisfies the condition, it returns nil
if the left-operand is a map, the keyword each will contain each value

unknown var4 <- [1::2, 3::4, 5::6] last_with (each >= 4); 	// var4 equals 6
unknown var5 <- [1::2, 3::4, 5::6].pairs last_with (each.value >= 4); 	// var5 equals 5::6

Examples:

unknown var0 <- [1,2,3,4,5,6,7,8] last_with (each > 3); 	// var0 equals 8
unknown var2 <- g2 last_with (length(g2 out_edges_of each) = 0 ); 	// var2 equals node11
unknown var3 <- (list(node) last_with (round(node(each).location.x) > 32); 	// var3 equals node3

`layout`

Possible use:

graph layout string —> graph
layout (graph , string) —> graph
layout (graph, string, int) —> graph
layout (graph, string, int, map<string,unknown>) —> graph

Result:

layouts a GAMA graph.

`length`

Possible use:

length (string) —> int
length (container<KeyType,ValueType>) —> int

Result:

the number of elements contained in the operand

Comment:

the length operator behavior depends on the nature of the operand

Special cases:

if it is a population, length returns number of agents of the population
if it is a graph, length returns the number of vertexes or of edges (depending on the way it was created)
if it is a string, length returns the number of characters

int var0 <- length ('I am an agent'); 	// var0 equals 13

if it is a list or a map, length returns the number of elements in the list or map

int var1 <- length([12,13]); 	// var1 equals 2
int var2 <- length([]); 	// var2 equals 0

if it is a matrix, length returns the number of cells

int var3 <- length(matrix([["c11","c12","c13"],["c21","c22","c23"]])); 	// var3 equals 6

`line`

Possible use:

line (container<geometry>) —> geometry
container<geometry> line float —> geometry
line (container<geometry> , float) —> geometry

Result:

A polyline geometry from the given list of points represented as a cylinder of radius r. A polyline geometry from the given list of points.

Special cases:

if the operand is nil, returns the point geometry {0,0}
if the operand is composed of a single point, returns a point geometry.
if the operand is nil, returns the point geometry {0,0}
if the operand is composed of a single point, returns a point geometry.
if a radius is added, the given list of points represented as a cylinder of radius r

geometry var0 <- polyline([{0,0}, {0,10}, {10,10}, {10,0}],0.2); 	// var0 equals a polyline geometry composed of the 4 points.

Examples:

geometry var1 <- polyline([{0,0}, {0,10}, {10,10}, {10,0}]); 	// var1 equals a polyline geometry composed of the 4 points.

`link`

Possible use:

geometry link geometry —> geometry
link (geometry , geometry) —> geometry

Result:

A dynamic line geometry between the location of the two operands

Comment:

The geometry of the link is a line between the locations of the two operands, which is built and maintained dynamically

Special cases:

if one of the operands is nil, link returns a point geometry at the location of the other. If both are null, it returns a point geometry at {0,0}

Examples:

geometry var0 <- link (geom1,geom2); 	// var0 equals a link geometry between geom1 and geom2.

`list`

Possible use:

list (any) —> list

Result:

Casts the operand into the type list

`list_with`

Possible use:

int list_with any expression —> container
list_with (int , any expression) —> container

Result:

creates a list with a size provided by the first operand, and filled with the second operand

Comment:

Note that the right operand should be positive, and that the second one is evaluated for each position in the list.

`ln`

Possible use:

ln (int) —> float
ln (float) —> float

Result:

Returns the natural logarithm (base e) of the operand.

Special cases:

an exception is raised if the operand is less than zero.

Examples:

float var0 <- ln(1); 	// var0 equals 0.0
float var1 <- ln(exp(1)); 	// var1 equals 1.0

`load_graph_from_file`

Possible use:

load_graph_from_file (string) —> graph
string load_graph_from_file file —> graph
load_graph_from_file (string , file) —> graph
string load_graph_from_file string —> graph
load_graph_from_file (string , string) —> graph
load_graph_from_file (string, species, species) —> graph
load_graph_from_file (string, file, species, species) —> graph
load_graph_from_file (string, string, species, species) —> graph
load_graph_from_file (string, string, species, species, bool) —> graph

Result:

loads a graph from a file returns a graph loaded from a given file encoded into a given format. The last boolean parameter indicates whether the resulting graph will be considered as spatial or not by GAMA

Comment:

Available formats: “pajek”: Pajek (Slovene word for Spider) is a program, for Windows, for analysis and visualization of large networks. See: http://pajek.imfm.si/doku.php?id=pajek for more details.”lgl”: LGL is a compendium of applications for making the visualization of large networks and trees tractable. See: http://lgl.sourceforge.net/ for more details.”dot”: DOT is a plain text graph description language. It is a simple way of describing graphs that both humans and computer programs can use. See: http://en.wikipedia.org/wiki/DOT_language for more details.”edge”: This format is a simple text file with numeric vertex ids defining the edges.”gexf”: GEXF (Graph Exchange XML Format) is a language for describing complex networks structures, their associated data and dynamics. Started in 2007 at Gephi project by different actors, deeply involved in graph exchange issues, the gexf specifications are mature enough to claim being both extensible and open, and suitable for real specific applications. See: http://gexf.net/format/ for more details.”graphml”: GraphML is a comprehensive and easy-to-use file format for graphs based on XML. See: http://graphml.graphdrawing.org/ for more details.”tlp” or “tulip”: TLP is the Tulip software graph format. See: http://tulip.labri.fr/TulipDrupal/?q=tlp-file-format for more details. “ncol”: This format is used by the Large Graph Layout progra. It is simply a symbolic weighted edge list. It is a simple text file with one edge per line. An edge is defined by two symbolic vertex names separated by whitespace. (The symbolic vertex names themselves cannot contain whitespace.) They might followed by an optional number, this will be the weight of the edge. See: http://bioinformatics.icmb.utexas.edu/lgl for more details.The map operand should includes following elements:Available formats: “pajek”: Pajek (Slovene word for Spider) is a program, for Windows, for analysis and visualization of large networks. See: http://pajek.imfm.si/doku.php?id=pajek for more details.”lgl”: LGL is a compendium of applications for making the visualization of large networks and trees tractable. See: http://lgl.sourceforge.net/ for more details.”dot”: DOT is a plain text graph description language. It is a simple way of describing graphs that both humans and computer programs can use. See: http://en.wikipedia.org/wiki/DOT_language for more details.”edge”: This format is a simple text file with numeric vertex ids defining the edges.”gexf”: GEXF (Graph Exchange XML Format) is a language for describing complex networks structures, their associated data and dynamics. Started in 2007 at Gephi project by different actors, deeply involved in graph exchange issues, the gexf specifications are mature enough to claim being both extensible and open, and suitable for real specific applications. See: http://gexf.net/format/ for more details.”graphml”: GraphML is a comprehensive and easy-to-use file format for graphs based on XML. See: http://graphml.graphdrawing.org/ for more details.”tlp” or “tulip”: TLP is the Tulip software graph format. See: http://tulip.labri.fr/TulipDrupal/?q=tlp-file-format for more details. “ncol”: This format is used by the Large Graph Layout progra. It is simply a symbolic weighted edge list. It is a simple text file with one edge per line. An edge is defined by two symbolic vertex names separated by whitespace. (The symbolic vertex names themselves cannot contain whitespace.) They might followed by an optional number, this will be the weight of the edge. See: http://bioinformatics.icmb.utexas.edu/lgl for more details.The map operand should includes following elements:

Special cases:

“format”: the format of the file
“filename”: the filename of the file containing the network
“edges_species”: the species of edges
“vertices_specy”: the species of vertices
“format”: the format of the file
“filename”: the filename of the file containing the network
“edges_species”: the species of edges
“vertices_specy”: the species of vertices
“format”: the format of the file, “file”: the file containing the network, “edges_species”: the species of edges, “vertices_specy”: the species of vertices

graph<myVertexSpecy,myEdgeSpecy> myGraph <- load_graph_from_file(
			"pajek",
			"example_of_Pajek_file",
			myVertexSpecy,
			myEdgeSpecy );

“filename”: the filename of the file containing the network, “edges_species”: the species of edges, “vertices_specy”: the species of vertices

graph<myVertexSpecy,myEdgeSpecy> myGraph <- load_graph_from_file(
			"pajek",
			"./example_of_Pajek_file",
			myVertexSpecy,
			myEdgeSpecy );

“file”: the file containing the network

graph<myVertexSpecy,myEdgeSpecy> myGraph <- load_graph_from_file(
			"pajek",
			"example_of_Pajek_file");

“format”: the format of the file, “file”: the file containing the network

graph<myVertexSpecy,myEdgeSpecy> myGraph <- load_graph_from_file(
			"pajek",
			"example_of_Pajek_file");

“format”: the format of the file, “filename”: the filename of the file containing the network

graph<myVertexSpecy,myEdgeSpecy> myGraph <- load_graph_from_file(
			"pajek",
			"example_of_Pajek_file");

Examples:

graph<myVertexSpecy,myEdgeSpecy> myGraph <- load_graph_from_file(
			"pajek",
			"./example_of_Pajek_file",
			myVertexSpecy,
			myEdgeSpecy);
graph<myVertexSpecy,myEdgeSpecy> myGraph <- load_graph_from_file(
			"pajek",
			"./example_of_Pajek_file",
			myVertexSpecy,
			myEdgeSpecy , true);

`load_shortest_paths`

Possible use:

graph load_shortest_paths matrix —> graph
load_shortest_paths (graph , matrix) —> graph

Result:

put in the graph cache the computed shortest paths contained in the matrix (rows: source, columns: target)

Examples:

graph var0 <- load_shortest_paths(shortest_paths_matrix); 	// var0 equals return my_graph with all the shortest paths computed

`log`

Possible use:

log (float) —> float
log (int) —> float

Result:

Returns the logarithm (base 10) of the operand.

Special cases:

an exception is raised if the operand is equals or less than zero.

Examples:

float var0 <- log(10); 	// var0 equals 1.0
float var1 <- log(1); 	// var1 equals 0.0

`lower_case`

Possible use:

lower_case (string) —> string

Result:

Converts all of the characters in the string operand to lower case

Examples:

string var0 <- lower_case("Abc"); 	// var0 equals 'abc'

`map`

Possible use:

map (any) —> map

Result:

Casts the operand into the type map

`masked_by`

Possible use:

geometry masked_by container<geometry> —> geometry
masked_by (geometry , container<geometry>) —> geometry
masked_by (geometry, container<geometry>, int) —> geometry

Examples:

geometry var0 <- perception_geom masked_by obstacle_list; 	// var0 equals the geometry representing the part of perception_geom visible from the agent position considering the list of obstacles obstacle_list.
geometry var1 <- perception_geom masked_by obstacle_list; 	// var1 equals the geometry representing the part of perception_geom visible from the agent position considering the list of obstacles obstacle_list.

`material`

Possible use:

float material float —> msi.gama.util.GamaMaterial
material (float , float) —> msi.gama.util.GamaMaterial

Result:

Returns

Examples:

`matrix`

Possible use:

matrix (any) —> matrix

Result:

Casts the operand into the type matrix

`matrix_with`

Possible use:

point matrix_with any expression —> matrix
matrix_with (point , any expression) —> matrix

Result:

creates a matrix with a size provided by the first operand, and filled with the second operand

Comment:

Note that both components of the right operand point should be positive, otherwise an exception is raised.

`max`

Possible use:

max (container) —> unknown

Result:

the maximum element found in the operand

Comment:

the max operator behavior depends on the nature of the operand

Special cases:

if it is a population of a list of other type: max transforms all elements into integer and returns the maximum of them
if it is a map, max returns the maximum among the list of all elements value
if it is a file, max returns the maximum of the content of the file (that is also a container)
if it is a graph, max returns the maximum of the list of the elements of the graph (that can be the list of edges or vertexes depending on the graph)
if it is a matrix of int, float or object, max returns the maximum of all the numerical elements (thus all elements for integer and float matrices)
if it is a matrix of geometry, max returns the maximum of the list of the geometries
if it is a matrix of another type, max returns the maximum of the elements transformed into float
if it is a list of int of float, max returns the maximum of all the elements

unknown var0 <- max ([100, 23.2, 34.5]); 	// var0 equals 100.0

if it is a list of points: max returns the maximum of all points as a point (i.e. the point with the greatest coordinate on the x-axis, in case of equality the point with the greatest coordinate on the y-axis is chosen. If all the points are equal, the first one is returned. )

unknown var1 <- max([{1.0,3.0},{3.0,5.0},{9.0,1.0},{7.0,8.0}]); 	// var1 equals {9.0,1.0}

`max_of`

Possible use:

container max_of any expression —> unknown
max_of (container , any expression) —> unknown

Result:

the maximum value of the right-hand expression evaluated on each of the elements of the left-hand operand

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

As of GAMA 1.6, if the left-hand operand is nil or empty, max_of throws an error
if the left-operand is a map, the keyword each will contain each value

unknown var5 <- [1::2, 3::4, 5::6] max_of (each + 3); 	// var5 equals 6

Examples:

unknown var1 <- [1,2,4,3,5,7,6,8] max_of (each * 100 ); 	// var1 equals 800
graph g2 <- as_edge_graph([{1,5}::{12,45},{12,45}::{34,56}]);
unknown var3 <- g2.vertices max_of (g2 degree_of( each )); 	// var3 equals 2
unknown var4 <- (list(node) max_of (round(node(each).location.x)); 	// var4 equals 96

`maximal_cliques_of`

Possible use:

maximal_cliques_of (graph) —> list<list>

Result:

returns the maximal cliques of a graph using the Bron-Kerbosch clique detection algorithm: A clique is maximal if it is impossible to enlarge it by adding another vertex from the graph. Note that a maximal clique is not necessarily the biggest clique in the graph.

Examples:

graph my_graph <- graph([]);
list<list> var1 <- maximal_cliques_of (my_graph); 	// var1 equals the list of all the maximal cliques as list

`mean`

Possible use:

mean (container) —> unknown

Result:

the mean of all the elements of the operand

Comment:

the elements of the operand are summed (see sum for more details about the sum of container elements ) and then the sum value is divided by the number of elements.

Special cases:

if the container contains points, the result will be a point. If the container contains rgb values, the result will be a rgb color

Examples:

unknown var0 <- mean ([4.5, 3.5, 5.5, 7.0]); 	// var0 equals 5.125

`mean_deviation`

Possible use:

mean_deviation (container) —> float

Result:

the deviation from the mean of all the elements of the operand. See Mean_deviation for more details.

Comment:

The operator casts all the numerical element of the list into float. The elements that are not numerical are discarded.

Examples:

float var0 <- mean_deviation ([4.5, 3.5, 5.5, 7.0]); 	// var0 equals 1.125

`mean_of`

Possible use:

container mean_of any expression —> unknown
mean_of (container , any expression) —> unknown

Result:

the mean of the right-hand expression evaluated on each of the elements of the left-hand operand

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

if the left-operand is a map, the keyword each will contain each value

unknown var2 <- [1::2, 3::4, 5::6] mean_of (each); 	// var2 equals 4

Examples:

unknown var1 <- [1,2] mean_of (each * 10 ); 	// var1 equals 15

`meanR`

Possible use:

meanR (container) —> unknown

Result:

returns the mean value of given vector (right-hand operand) in given variable (left-hand operand).

Examples:

list<int> X <- [2, 3, 1];
int var1 <- meanR(X); 	// var1 equals 2

`median`

Possible use:

median (container) —> unknown

Result:

the median of all the elements of the operand.

Special cases:

if the container contains points, the result will be a point. If the container contains rgb values, the result will be a rgb color

Examples:

unknown var0 <- median ([4.5, 3.5, 5.5, 3.4, 7.0]); 	// var0 equals 5.0

`message`

Possible use:

message (unknown) —> msi.gama.extensions.messaging.GamaMessage

Result:

to be added

`milliseconds_between`

Possible use:

date milliseconds_between date —> float
milliseconds_between (date , date) —> float

Result:

Provide the exact number of milliseconds between two dates. This number can be positive or negative (if the second operand is smaller than the first one)

Examples:

milliseconds_between(d1, d2) -: 10

`min`

Possible use:

min (container) —> unknown

Result:

the minimum element found in the operand.

Comment:

the min operator behavior depends on the nature of the operand

Special cases:

if it is a list of points: min returns the minimum of all points as a point (i.e. the point with the smallest coordinate on the x-axis, in case of equality the point with the smallest coordinate on the y-axis is chosen. If all the points are equal, the first one is returned. )
if it is a population of a list of other types: min transforms all elements into integer and returns the minimum of them
if it is a map, min returns the minimum among the list of all elements value
if it is a file, min returns the minimum of the content of the file (that is also a container)
if it is a graph, min returns the minimum of the list of the elements of the graph (that can be the list of edges or vertexes depending on the graph)
if it is a matrix of int, float or object, min returns the minimum of all the numerical elements (thus all elements for integer and float matrices)
if it is a matrix of geometry, min returns the minimum of the list of the geometries
if it is a matrix of another type, min returns the minimum of the elements transformed into float
if it is a list of int or float: min returns the minimum of all the elements

unknown var0 <- min ([100, 23.2, 34.5]); 	// var0 equals 23.2

`min_of`

Possible use:

container min_of any expression —> unknown
min_of (container , any expression) —> unknown

Result:

the minimum value of the right-hand expression evaluated on each of the elements of the left-hand operand

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

if the left-hand operand is nil or empty, min_of throws an error
if the left-operand is a map, the keyword each will contain each value

unknown var5 <- [1::2, 3::4, 5::6] min_of (each + 3); 	// var5 equals 5

Examples:

unknown var1 <- [1,2,4,3,5,7,6,8] min_of (each * 100 ); 	// var1 equals 100
graph g2 <- as_edge_graph([{1,5}::{12,45},{12,45}::{34,56}]);
unknown var3 <- g2 min_of (length(g2 out_edges_of each) ); 	// var3 equals 0
unknown var4 <- (list(node) min_of (round(node(each).location.x)); 	// var4 equals 4

`minus_days`

Possible use:

date minus_days int —> date
minus_days (date , int) —> date

Result:

Subtract a given number of days from a date

Examples:

date1 minus_days 20

`minus_hours`

Possible use:

date minus_hours int —> date
minus_hours (date , int) —> date

Result:

Remove a given number of hours from a date

Examples:

date1 minus_hours 15 // equivalent to date1 - 15 #h

`minus_minutes`

Possible use:

date minus_minutes int —> date
minus_minutes (date , int) —> date

Result:

Subtract a given number of minutes from a date

Examples:

date1 minus_minutes 5 // equivalent to date1 - 5#mn

`minus_months`

Possible use:

date minus_months int —> date
minus_months (date , int) —> date

Result:

Subtract a given number of months from a date

Examples:

date1 minus_months 5

`minus_ms`

Possible use:

date minus_ms int —> date
minus_ms (date , int) —> date

Result:

Remove a given number of milliseconds from a date

Examples:

date1 minus_ms 15 // equivalent to date1 - 15 #ms

`minus_seconds`

Same signification as -

`minus_weeks`

Possible use:

date minus_weeks int —> date
minus_weeks (date , int) —> date

Result:

Subtract a given number of weeks from a date

Examples:

date1 minus_weeks 15

`minus_years`

Possible use:

date minus_years int —> date
minus_years (date , int) —> date

Result:

Subtract a given number of year from a date

Examples:

date1 minus_years 3

`mod`

Possible use:

int mod int —> int
mod (int , int) —> int

Result:

Returns the remainder of the integer division of the left-hand operand by the right-hand operand.

Special cases:

if operands are float, they are truncated
if the right-hand operand is equal to zero, raises an exception.

Examples:

int var0 <- 40 mod 3; 	// var0 equals 1

`months_between`

Possible use:

date months_between date —> int
months_between (date , date) —> int

Result:

Provide the exact number of months between two dates. This number can be positive or negative (if the second operand is smaller than the first one)

Examples:

months_between(d1, d2) -: 10

`moran`

Possible use:

list<float> moran matrix<float> —> float
moran (list<float> , matrix<float>) —> float

Special cases:

return the Moran Index of the given list of interest points (list of floats) and the weight matrix (matrix of float)

float var0 <- moran([1.0, 0.5, 2.0], weight_matrix); 	// var0 equals the Moran index computed

`mul`

Possible use:

mul (container) —> unknown

Result:

the product of all the elements of the operand

Comment:

the mul operator behavior depends on the nature of the operand

Special cases:

if it is a list of points: mul returns the product of all points as a point (each coordinate is the product of the corresponding coordinate of each element)
if it is a list of other types: mul transforms all elements into integer and multiplies them
if it is a map, mul returns the product of the value of all elements
if it is a file, mul returns the product of the content of the file (that is also a container)
if it is a graph, mul returns the product of the list of the elements of the graph (that can be the list of edges or vertexes depending on the graph)
if it is a matrix of int, float or object, mul returns the product of all the numerical elements (thus all elements for integer and float matrices)
if it is a matrix of geometry, mul returns the product of the list of the geometries
if it is a matrix of other types: mul transforms all elements into float and multiplies them
if it is a list of int or float: mul returns the product of all the elements

unknown var0 <- mul ([100, 23.2, 34.5]); 	// var0 equals 80040.0

`nb_cycles`

Possible use:

nb_cycles (graph) —> int

Result:

returns the maximum number of independent cycles in a graph. This number (u) is estimated through the number of nodes (v), links (e) and of sub-graphs (p): u = e - v + p.

Examples:

graph graphEpidemio <- graph([]);
int var1 <- nb_cycles(graphEpidemio); 	// var1 equals the number of cycles in the graph

`neighbors_at`

Possible use:

geometry neighbors_at float —> container
neighbors_at (geometry , float) —> container

Result:

a list, containing all the agents of the same species than the left argument (if it is an agent) located at a distance inferior or equal to the right-hand operand to the left-hand operand (geometry, agent, point).

Comment:

The topology used to compute the neighborhood is the one of the left-operand if this one is an agent; otherwise the one of the agent applying the operator.

Examples:

container var0 <- (self neighbors_at (10)); 	// var0 equals all the agents located at a distance lower or equal to 10 to the agent applying the operator.

`neighbors_of`

Possible use:

graph neighbors_of unknown —> container
neighbors_of (graph , unknown) —> container
topology neighbors_of agent —> container
neighbors_of (topology , agent) —> container
neighbors_of (topology, geometry, float) —> container

Result:

a list, containing all the agents of the same species than the argument (if it is an agent) located at a distance inferior or equal to 1 to the right-hand operand agent considering the left-hand operand topology.

Special cases:

a list, containing all the agents of the same species than the left argument (if it is an agent) located at a distance inferior or equal to the third argument to the second argument (agent, geometry or point) considering the first operand topology.

container var3 <- neighbors_of (topology(self), self,10); 	// var3 equals all the agents located at a distance lower or equal to 10 to the agent applying the operator considering its topology.

Examples:

container var0 <- graphEpidemio neighbors_of (node(3)); 	// var0 equals [node0,node2]
container var1 <- graphFromMap neighbors_of node({12,45}); 	// var1 equals [{1.0,5.0},{34.0,56.0}]
container var2 <- topology(self) neighbors_of self; 	// var2 equals returns all the agents located at a distance lower or equal to 1 to the agent applying the operator considering its topology.

`new_emotion`

Possible use:

new_emotion (string) —> emotion
string new_emotion agent —> emotion
new_emotion (string , agent) —> emotion
string new_emotion float —> emotion
new_emotion (string , float) —> emotion
string new_emotion predicate —> emotion
new_emotion (string , predicate) —> emotion
new_emotion (string, float, predicate) —> emotion
new_emotion (string, float, float) —> emotion
new_emotion (string, predicate, agent) —> emotion
new_emotion (string, float, agent) —> emotion
new_emotion (string, float, float, agent) —> emotion
new_emotion (string, float, predicate, float) —> emotion
new_emotion (string, float, predicate, agent) —> emotion
new_emotion (string, float, predicate, float, agent) —> emotion

Result:

a new emotion with the given properties (name) a new emotion with the given properties (name) a new emotion with the given properties (name,intensity,about) a new emotion with the given properties (name,intensity,decay) a new emotion with the given properties (name) a new emotion with the given properties (name, intensity) a new emotion with the given properties (name,about) a new emotion with the given properties (name) a new emotion with the given properties (name) a new emotion with the given properties (name) a new emotion with the given properties (name) a new emotion with the given properties (name)

Examples:

emotion("joy",12.3,eatFood,4)
emotion("joy",12.3,eatFood,4)
emotion("joy",12.3,eatFood)
emotion("joy",12.3,4)
emotion("joy",12.3,eatFood,4)
emotion("joy",12.3)
emotion("joy",eatFood)
emotion("joy")
emotion("joy",12.3,eatFood,4)
emotion("joy",12.3,eatFood,4)
emotion("joy",12.3,eatFood,4)
emotion("joy",12.3,eatFood,4)

`new_folder`

Possible use:

new_folder (string) —> file

Result:

opens an existing repository or create a new folder if it does not exist.

Special cases:

If the specified string does not refer to an existing repository, the repository is created.
If the string refers to an existing file, an exception is risen.

Examples:

file dirNewT <- new_folder("incl/");   	// dirNewT represents the repository "../incl/"
															// eventually creates the directory ../incl

`new_predicate`

Possible use:

new_predicate (string) —> predicate
string new_predicate agent —> predicate
new_predicate (string , agent) —> predicate
string new_predicate float —> predicate
new_predicate (string , float) —> predicate
string new_predicate int —> predicate
new_predicate (string , int) —> predicate
string new_predicate map —> predicate
new_predicate (string , map) —> predicate
string new_predicate bool —> predicate
new_predicate (string , bool) —> predicate
new_predicate (string, map, float) —> predicate
new_predicate (string, map, int) —> predicate
new_predicate (string, map, agent) —> predicate
new_predicate (string, map, bool) —> predicate
new_predicate (string, map, int, bool) —> predicate
new_predicate (string, map, bool, agent) —> predicate
new_predicate (string, map, float, int) —> predicate
new_predicate (string, map, int, agent) —> predicate
new_predicate (string, map, float, agent) —> predicate
new_predicate (string, map, float, bool) —> predicate
new_predicate (string, map, float, int, bool) —> predicate
new_predicate (string, map, int, bool, agent) —> predicate
new_predicate (string, map, float, bool, agent) —> predicate
new_predicate (string, map, float, int, agent) —> predicate
new_predicate (string, map, float, int, bool, agent) —> predicate

Result:

a new predicate with the given properties (name, values, lifetime, is_true) a new predicate with the given properties (name, values, priority) a new predicate with the given properties (name, values, priority, lifetime, is_true, agentCause) a new predicate with the given properties (name, values, is_true, agentCause) a new predicate with the given properties (name, values, lifetime) a new predicate with the given properties (name, values, priority, lifetime, is_true) a new predicate with the given properties (name, values, lifetime, is_true, agentCause) a new predicate with the given is_true (name, priority) a new predicate with the given is_true (name, lifetime) a new predicate with the given properties (name, values) a new predicate with the given properties (name, values, lifetime) a new predicate with the given is_true (name, is_true) a new predicate with the given properties (name, values, priority,lifetime) a new predicate with the given properties (name, values, priority, is_true, agentCause) a new predicate with the given properties (name, values, agentCause) a new predicate with the given properties (name, values, lifetime, agentCause) a new predicate with the given properties (name) a new predicate with the given properties (name, values, priority, agentCause) a new predicate with the given properties (name, values, priority, is_true) a new predicate with the given properties (name, values, priority, lifetime, agentCause) a new predicate with the given properties (name, values, is_true)

Examples:

predicate("people to meet", ["time"::10], 10,true)
predicate("people to meet", people1, ["time"::10])
predicate("people to meet", ["time"::10],2.0,10, true, agentA)
predicate("people to meet", ["time"::10], true, agentA)
predicate("people to meet", ["time"::10], true)
predicate("people to meet", ["time"::10],2.0,10, true)
predicate("people to meet", ["time"::10], 10, true, agentA)
predicate("hasWater", 2.0 )
predicate("hasWater", 10 
predicate("people to meet", people1 )
predicate("people to meet", ["time"::10], true)
predicate("hasWater", true)
predicate("people to meet", ["time"::10], 2.0,10)
predicate("people to meet", ["time"::10], 2.0, true, agentA)
predicate("people to meet", ["time"::10], agentA)
predicate("people to meet", ["time"::10], 10, agentA)
predicate("people to meet")
predicate("people to meet", ["time"::10], 2.0,agentA)
predicate("people to meet", ["time"::10],2.0, true)
predicate("people to meet", ["time"::10], 2.0,10,agentA)
predicate("people to meet", ["time"::10], true)

`new_social_link`

Possible use:

new_social_link (agent) —> msi.gaml.architecture.simplebdi.SocialLink
new_social_link (agent, float, float, float, float) —> msi.gaml.architecture.simplebdi.SocialLink

Result:

a new social link a new social link

Examples:

new_social_link(agentA)
new_social_link(agentA,0.0,-0.1,0.2,0.1)

`node`

Possible use:

node (unknown) —> unknown
unknown node float —> unknown
node (unknown , float) —> unknown

`nodes`

Possible use:

nodes (container) —> container

`norm`

Possible use:

norm (point) —> float

Result:

the norm of the vector with the coordinates of the point operand.

Examples:

float var0 <- norm({3,4}); 	// var0 equals 5.0

`not`

Same signification as !

`obj_file`

Possible use:

obj_file (string) —> file

Result:

Constructs a file of type obj. Allowed extensions are limited to obj, OBJ

`of`

Same signification as .

`of_generic_species`

Possible use:

container of_generic_species species —> container
of_generic_species (container , species) —> container

Result:

a list, containing the agents of the left-hand operand whose species is that denoted by the right-hand operand and whose species extends the right-hand operand species

Examples:

// species test {}
// species sous_test parent: test {}
container var2 <- [sous_test(0),sous_test(1),test(2),test(3)] of_generic_species test; 	// var2 equals [sous_test0,sous_test1,test2,test3]
container var3 <- [sous_test(0),sous_test(1),test(2),test(3)] of_generic_species sous_test; 	// var3 equals [sous_test0,sous_test1]
container var4 <- [sous_test(0),sous_test(1),test(2),test(3)] of_species test; 	// var4 equals [test2,test3]
container var5 <- [sous_test(0),sous_test(1),test(2),test(3)] of_species sous_test; 	// var5 equals [sous_test0,sous_test1]

`of_species`

Possible use:

container of_species species —> container
of_species (container , species) —> container

Result:

a list, containing the agents of the left-hand operand whose species is the one denoted by the right-hand operand.The expression agents of_species (species self) is equivalent to agents where (species each = species self); however, the advantage of using the first syntax is that the resulting list is correctly typed with the right species, whereas, in the second syntax, the parser cannot determine the species of the agents within the list (resulting in the need to cast it explicitly if it is to be used in an ask statement, for instance).

Special cases:

if the right operand is nil, of_species returns the right operand

Examples:

container var0 <- (self neighbors_at 10) of_species (species (self)); 	// var0 equals all the neighboring agents of the same species.
container var1 <- [test(0),test(1),node(1),node(2)] of_species test; 	// var1 equals [test0,test1]

`one_of`

Possible use:

one_of (container<KeyType,ValueType>) —> ValueType

Result:

one of the values stored in this container at a random key

Comment:

the one_of operator behavior depends on the nature of the operand

Special cases:

if it is a graph, one_of returns one of the lists of edges
if it is a file, one_of returns one of the elements of the content of the file (that is also a container)
if the operand is empty, one_of returns nil

if it is a list or a matrix, one_of returns one of the values of the list or of the matrix

int i <- any ([1,2,3]); 	// i equals 1, 2 or 3
string sMat <- one_of(matrix([["c11","c12","c13"],["c21","c22","c23"]])); 	// sMat equals "c11","c12","c13", "c21","c22" or "c23"

if it is a map, one_of returns one the value of a random pair of the map

int im <- one_of ([2::3, 4::5, 6::7]);	// im equals 3, 5 or 7
bool var6 <- [2::3, 4::5, 6::7].values contains im; 	// var6 equals true

if it is a population, one_of returns one of the agents of the population

bug b <- one_of(bug);  	// Given a previously defined species bug, b is one of the created bugs, e.g. bug3

`or`

Possible use:

bool or any expression —> bool
or (bool , any expression) —> bool

Result:

a bool value, equal to the logical or between the left-hand operand and the right-hand operand.

Comment:

both operands are always casted to bool before applying the operator. Thus, an expression like 1 or 0 is accepted and returns true.

`or`

Possible use:

predicate or predicate —> predicate
or (predicate , predicate) —> predicate

Result:

create a new predicate from two others by including them as subintentions. It’s an exclusive “or”

Examples:

predicate1 or predicate2

`osm_file`

Possible use:

string osm_file map<string,list> —> file
osm_file (string , map<string,list>) —> file
osm_file (string, map<string,list>, int) —> file

Result:

opens a file that a is a kind of OSM file with some filtering. opens a file that a is a kind of OSM file with some filtering, forcing the initial CRS to be the one indicated by the second int parameter (see http://spatialreference.org/ref/epsg/). If this int parameter is equal to 0, the data is considered as already projected.

Comment:

The file should have a OSM file extension, cf. file type definition for supported file extensions.The file should have a OSM file extension, cf. file type definition for supported file extensions.

Special cases:

If the specified string does not refer to an existing OSM file, an exception is risen.
If the specified string does not refer to an existing OSM file, an exception is risen.

Examples:

file myOSMfile <- osm_file("../includes/rouen.osm", ["highway"::["primary","motorway"]]);
file myOSMfile2 <- osm_file("../includes/rouen.osm",["highway"::["primary","motorway"]], 0);

`out_degree_of`

Possible use:

graph out_degree_of unknown —> int
out_degree_of (graph , unknown) —> int

Result:

returns the out degree of a vertex (right-hand operand) in the graph given as left-hand operand.

Examples:

int var1 <- graphFromMap out_degree_of (node(3)); 	// var1 equals 4

`out_edges_of`

Possible use:

graph out_edges_of unknown —> container
out_edges_of (graph , unknown) —> container

Result:

returns the list of the out-edges of a vertex (right-hand operand) in the graph given as left-hand operand.

Examples:

container var1 <- graphFromMap out_edges_of (node(3)); 	// var1 equals 3

`overlapping`

Possible use:

container<agent> overlapping geometry —> list<geometry>
overlapping (container<agent> , geometry) —> list<geometry>

Result:

A list of agents or geometries among the left-operand list, species or meta-population (addition of species), overlapping the operand (casted as a geometry).

Examples:

list<geometry> var0 <- [ag1, ag2, ag3] overlapping(self); 	// var0 equals return the agents among ag1, ag2 and ag3 that overlap the shape of the agent applying the operator.
(species1 + species2) overlapping self

`overlaps`

Possible use:

geometry overlaps geometry —> bool
overlaps (geometry , geometry) —> bool

Result:

A boolean, equal to true if the left-geometry (or agent/point) overlaps the right-geometry (or agent/point).

Special cases:

if one of the operand is null, returns false.
if one operand is a point, returns true if the point is included in the geometry

Examples:

bool var0 <- polyline([{10,10},{20,20}]) overlaps polyline([{15,15},{25,25}]); 	// var0 equals true
bool var1 <- polygon([{10,10},{10,20},{20,20},{20,10}]) overlaps polygon([{15,15},{15,25},{25,25},{25,15}]); 	// var1 equals true
bool var2 <- polygon([{10,10},{10,20},{20,20},{20,10}]) overlaps {25,25}; 	// var2 equals false
bool var3 <- polygon([{10,10},{10,20},{20,20},{20,10}]) overlaps polygon([{35,35},{35,45},{45,45},{45,35}]); 	// var3 equals false
bool var4 <- polygon([{10,10},{10,20},{20,20},{20,10}]) overlaps polyline([{10,10},{20,20}]); 	// var4 equals true
bool var5 <- polygon([{10,10},{10,20},{20,20},{20,10}]) overlaps {15,15}; 	// var5 equals true
bool var6 <- polygon([{10,10},{10,20},{20,20},{20,10}]) overlaps polygon([{0,0},{0,30},{30,30}, {30,0}]); 	// var6 equals true
bool var7 <- polygon([{10,10},{10,20},{20,20},{20,10}]) overlaps polygon([{15,15},{15,25},{25,25},{25,15}]); 	// var7 equals true
bool var8 <- polygon([{10,10},{10,20},{20,20},{20,10}]) overlaps polygon([{10,20},{20,20},{20,30},{10,30}]); 	// var8 equals true

`pair`

Possible use:

pair (any) —> pair

Result:

Casts the operand into the type pair

`partially_overlaps`

Possible use:

geometry partially_overlaps geometry —> bool
partially_overlaps (geometry , geometry) —> bool

Result:

A boolean, equal to true if the left-geometry (or agent/point) partially overlaps the right-geometry (or agent/point).

Comment:

if one geometry operand fully covers the other geometry operand, returns false (contrarily to the overlaps operator).

Special cases:

if one of the operand is null, returns false.

Examples:

bool var0 <- polyline([{10,10},{20,20}]) partially_overlaps polyline([{15,15},{25,25}]); 	// var0 equals true
bool var1 <- polygon([{10,10},{10,20},{20,20},{20,10}]) partially_overlaps polygon([{15,15},{15,25},{25,25},{25,15}]); 	// var1 equals true
bool var2 <- polygon([{10,10},{10,20},{20,20},{20,10}]) partially_overlaps {25,25}; 	// var2 equals false
bool var3 <- polygon([{10,10},{10,20},{20,20},{20,10}]) partially_overlaps polygon([{35,35},{35,45},{45,45},{45,35}]); 	// var3 equals false
bool var4 <- polygon([{10,10},{10,20},{20,20},{20,10}]) partially_overlaps polyline([{10,10},{20,20}]); 	// var4 equals false
bool var5 <- polygon([{10,10},{10,20},{20,20},{20,10}]) partially_overlaps {15,15}; 	// var5 equals false
bool var6 <- polygon([{10,10},{10,20},{20,20},{20,10}]) partially_overlaps polygon([{0,0},{0,30},{30,30}, {30,0}]); 	// var6 equals false
bool var7 <- polygon([{10,10},{10,20},{20,20},{20,10}]) partially_overlaps polygon([{15,15},{15,25},{25,25},{25,15}]); 	// var7 equals true
bool var8 <- polygon([{10,10},{10,20},{20,20},{20,10}]) partially_overlaps polygon([{10,20},{20,20},{20,30},{10,30}]); 	// var8 equals false

`path`

Possible use:

path (any) —> path

Result:

Casts the operand into the type path

`path_between`

Possible use:

topology path_between container<geometry> —> path
path_between (topology , container<geometry>) —> path
list<agent> path_between container<geometry> —> path
path_between (list<agent> , container<geometry>) —> path
path_between (graph, geometry, geometry) —> path
path_between (list<agent>, geometry, geometry) —> path
path_between (topology, geometry, geometry) —> path

Result:

The shortest path between a list of two objects in a graph The shortest path between two objects according to set of cells The shortest path between several objects according to set of cells

Examples:

path var0 <- path_between (my_graph, ag1, ag2); 	// var0 equals A path between ag1 and ag2
path var1 <- my_topology path_between [ag1, ag2]; 	// var1 equals A path between ag1 and ag2
path var2 <- path_between (cell_grid where each.is_free, ag1, ag2); 	// var2 equals A path between ag1 and ag2 passing through the given cell_grid agents
path var3 <- my_topology path_between (ag1, ag2); 	// var3 equals A path between ag1 and ag2
path var4 <- path_between (cell_grid where each.is_free, [ag1, ag2, ag3]); 	// var4 equals A path between ag1 and ag2 and ag3 passing through the given cell_grid agents

`path_to`

Possible use:

geometry path_to geometry —> path
path_to (geometry , geometry) —> path
point path_to point —> path
path_to (point , point) —> path

Result:

A path between two geometries (geometries, agents or points) considering the topology of the agent applying the operator.

Examples:

path var0 <- ag1 path_to ag2; 	// var0 equals the path between ag1 and ag2 considering the topology of the agent applying the operator

`paths_between`

Possible use:

paths_between (graph, pair, int) —> list<path>

Result:

The K shortest paths between a list of two objects in a graph

Examples:

list<path> var0 <- paths_between(my_graph, ag1:: ag2, 2); 	// var0 equals the 2 shortest paths (ordered by length) between ag1 and ag2

`percent_absolute_deviation`

Possible use:

list<float> percent_absolute_deviation list<float> —> float
percent_absolute_deviation (list<float> , list<float>) —> float

Result:

percent absolute deviation indicator for 2 series of values: percent_absolute_deviation(list_vals_observe,list_vals_sim)

Examples:

percent_absolute_deviation([200,300,150,150,200],[250,250,100,200,200])

`pgm_file`

Possible use:

pgm_file (string) —> file

Result:

Constructs a file of type pgm. Allowed extensions are limited to pgm

`plan`

Possible use:

container<geometry> plan float —> geometry
plan (container<geometry> , float) —> geometry

Result:

A polyline geometry from the given list of points.

Special cases:

if the operand is nil, returns the point geometry {0,0}
if the operand is composed of a single point, returns a point geometry.

Examples:

geometry var0 <- polyplan([{0,0}, {0,10}, {10,10}, {10,0}],10); 	// var0 equals a polyline geometry composed of the 4 points with a depth of 10.

`plus_days`

Possible use:

date plus_days int —> date
plus_days (date , int) —> date

Result:

Add a given number of days to a date

Examples:

date1 plus_days 20

`plus_hours`

Possible use:

date plus_hours int —> date
plus_hours (date , int) —> date

Result:

Add a given number of hours to a date

Examples:

date1 plus_hours 15 // equivalent to date1 + 15 #h

`plus_minutes`

Possible use:

date plus_minutes int —> date
plus_minutes (date , int) —> date

Result:

Add a given number of minutes to a date

Examples:

date1 plus_minutes 5 // equivalent to date1 + 5 #mn

`plus_months`

Possible use:

date plus_months int —> date
plus_months (date , int) —> date

Result:

Add a given number of months to a date

Examples:

date1 plus_months 5

`plus_ms`

Possible use:

date plus_ms int —> date
plus_ms (date , int) —> date

Result:

Add a given number of milliseconds to a date

Examples:

date1 plus_ms 15 // equivalent to date1 + 15 #ms

`plus_seconds`

Same signification as +

`plus_weeks`

Possible use:

date plus_weeks int —> date
plus_weeks (date , int) —> date

Result:

Add a given number of weeks to a date

Examples:

date1 plus_weeks 15

`plus_years`

Possible use:

date plus_years int —> date
plus_years (date , int) —> date

Result:

Add a given number of years to a date

Examples:

date1 plus_years 3

`point`

Possible use:

float point int —> point
point (float , int) —> point
int point float —> point
point (int , float) —> point
int point int —> point
point (int , int) —> point
float point float —> point
point (float , float) —> point
point (float, int, int) —> point
point (int, int, int) —> point
point (float, int, float) —> point
point (int, int, float) —> point
point (int, float, float) —> point
point (float, float, float) —> point
point (float, float, int) —> point

Result:

internal use only. Use the standard construction {x,y} instead. internal use only. Use the standard construction {x,y} instead. internal use only. Use the standard construction {x,y, z} instead. internal use only. Use the standard construction {x,y, z} instead. internal use only. Use the standard construction {x,y, z} instead. internal use only. Use the standard construction {x,y, z} instead. internal use only. Use the standard construction {x,y, z} instead. internal use only. Use the standard construction {x,y} instead. internal use only. Use the standard construction {x,y} instead. internal use only. Use the standard construction {x,y, z} instead. internal use only. Use the standard construction {x,y, z} instead.

`points_along`

Possible use:

geometry points_along list<float> —> container
points_along (geometry , list<float>) —> container

Result:

A list of points along the operand-geometry given its location in terms of rate of distance from the starting points of the geometry.

Examples:

container var0 <-  line([{10,10},{80,80}]) points_along ([0.3, 0.5, 0.9]); 	// var0 equals the list of following points: [{31.0,31.0,0.0},{45.0,45.0,0.0},{73.0,73.0,0.0}]

`points_at`

Possible use:

int points_at float —> list<point>
points_at (int , float) —> list<point>

Result:

A list of left-operand number of points located at a the right-operand distance to the agent location.

Examples:

list<point> var0 <- 3 points_at(20.0); 	// var0 equals returns [pt1, pt2, pt3] with pt1, pt2 and pt3 located at a distance of 20.0 to the agent location

`points_on`

Possible use:

geometry points_on float —> container
points_on (geometry , float) —> container

Result:

A list of points of the operand-geometry distant from each other to the float right-operand .

Examples:

container var0 <-  square(5) points_on(2); 	// var0 equals a list of points belonging to the exterior ring of the square distant from each other of 2.

`poisson`

Possible use:

poisson (float) —> int

Result:

A value from a random variable following a Poisson distribution (with the positive expected number of occurence lambda as operand).

Comment:

The Poisson distribution is a discrete probability distribution that expresses the probability of a given number of events occurring in a fixed interval of time and/or space if these events occur with a known average rate and independently of the time since the last event, cf. Poisson distribution on Wikipedia.

Examples:

int var0 <- poisson(3.5); 	// var0 equals a random positive integer

`polygon`

Possible use:

polygon (container<agent>) —> geometry

Result:

A polygon geometry from the given list of points.

Special cases:

if the operand is nil, returns the point geometry {0,0}
if the operand is composed of a single point, returns a point geometry
if the operand is composed of 2 points, returns a polyline geometry.

Examples:

geometry var0 <- polygon([{0,0}, {0,10}, {10,10}, {10,0}]); 	// var0 equals a polygon geometry composed of the 4 points.

`polyhedron`

Possible use:

container<geometry> polyhedron float —> geometry
polyhedron (container<geometry> , float) —> geometry

Result:

A polyhedron geometry from the given list of points.

Special cases:

if the operand is nil, returns the point geometry {0,0}
if the operand is composed of a single point, returns a point geometry
if the operand is composed of 2 points, returns a polyline geometry.

Examples:

geometry var0 <- polyhedron([{0,0}, {0,10}, {10,10}, {10,0}],10); 	// var0 equals a polygon geometry composed of the 4 points and of depth 10.

`polyline`

Same signification as line

`polyplan`

Same signification as plan

`predecessors_of`

Possible use:

graph predecessors_of unknown —> container
predecessors_of (graph , unknown) —> container

Result:

returns the list of predecessors (i.e. sources of in edges) of the given vertex (right-hand operand) in the given graph (left-hand operand)

Examples:

container var1 <- graphEpidemio predecessors_of ({1,5}); 	// var1 equals []
container var2 <- graphEpidemio predecessors_of node({34,56}); 	// var2 equals [{12;45}]

`predicate`

Possible use:

predicate (any) —> predicate

Result:

Casts the operand into the type predicate

`predict`

Possible use:

regression predict list<float> —> float
predict (regression , list<float>) —> float

Result:

returns the value predict by the regression parameters for a given instance. Usage: predict(regression, instance)

Examples:

predict(my_regression, [1,2,3]

`product`

Same signification as mul

`product_of`

Possible use:

container product_of any expression —> unknown
product_of (container , any expression) —> unknown

Result:

the product of the right-hand expression evaluated on each of the elements of the left-hand operand

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

if the left-operand is a map, the keyword each will contain each value

unknown var2 <- [1::2, 3::4, 5::6] product_of (each); 	// var2 equals 48

Examples:

unknown var1 <- [1,2] product_of (each * 10 ); 	// var1 equals 200

`promethee_DM`

Possible use:

list<list> promethee_DM list<map<string,object>> —> int
promethee_DM (list<list> , list<map<string,object>>) —> int

Result:

The index of the best candidate according to the Promethee II method. This method is based on a comparison per pair of possible candidates along each criterion: all candidates are compared to each other by pair and ranked. More information about this method can be found in [http://www.sciencedirect.com/science?_ob=ArticleURL&_udi=B6VCT-4VF56TV-1&_user=10&_coverDate=01%2F01%2F2010&_rdoc=1&_fmt=high&_orig=search&_sort=d&_docanchor=&view=c&_searchStrId=1389284642&_rerunOrigin=google&_acct=C000050221&_version=1&_urlVersion=0&_userid=10&md5=d334de2a4e0d6281199a39857648cd36 Behzadian, M., Kazemzadeh, R., Albadvi, A., M., A.: PROMETHEE: A comprehensive literature review on methodologies and applications. European Journal of Operational Research(2009)]. The first operand is the list of candidates (a candidate is a list of criterion values); the second operand the list of criterion: A criterion is a map that contains fours elements: a name, a weight, a preference value (p) and an indifference value (q). The preference value represents the threshold from which the difference between two criterion values allows to prefer one vector of values over another. The indifference value represents the threshold from which the difference between two criterion values is considered significant.

Special cases:

returns -1 is the list of candidates is nil or empty

Examples:

int var0 <- promethee_DM([[1.0, 7.0],[4.0,2.0],[3.0, 3.0]], [["name"::"utility", "weight" :: 2.0,"p"::0.5, "q"::0.0, "s"::1.0, "maximize" :: true],["name"::"price", "weight" :: 1.0,"p"::0.5, "q"::0.0, "s"::1.0, "maximize" :: false]]); 	// var0 equals 1

`property_file`

Possible use:

property_file (string) —> file

Result:

Constructs a file of type property. Allowed extensions are limited to properties

`pyramid`

Possible use:

pyramid (float) —> geometry

Result:

A square geometry which side size is given by the operand.

Comment:

the center of the pyramid is by default the location of the current agent in which has been called this operator.

Special cases:

returns nil if the operand is nil.

Examples:

geometry var0 <- pyramid(5); 	// var0 equals a geometry as a square with side_size = 5.

`R_correlation`

Same signification as corR

`R_file`

Possible use:

R_file (string) —> file

Result:

Constructs a file of type R. Allowed extensions are limited to r

`R_mean`

Same signification as meanR

`range`

Possible use:

range (int) —> container
int range int —> container
range (int , int) —> container
range (int, int, int) —> container

Result:

Allows to build a list of int representing all contiguous values from zero to the argument. The range can be increasing or decreasing. Passing 0 will return a singleton list with 0 Allows to build a list of int representing all contiguous values from the first to the second argument, using the step represented by the third argument. The range can be increasing or decreasing. Passing the same value for both will return a singleton list with this value. Passing a step of 0 will result in an exception. Attempting to build infinite ranges (e.g. end > start with a negative step) will similarly not be accepted and yield an exception Allows to build a list of int representing all contiguous values from the first to the second argument. The range can be increasing or decreasing. Passing the same value for both will return a singleton list with this value

`read`

Possible use:

read (string) —> unknown

Result:

Reads an attribute of the agent. The attribute’s name is specified by the operand.

Examples:

unknown agent_name <- read ('name'); 	// agent_name equals reads the 'name' variable of agent then assigns the returned value to the 'agent_name' variable.

`rectangle`

Possible use:

rectangle (point) —> geometry
float rectangle float —> geometry
rectangle (float , float) —> geometry
point rectangle point —> geometry
rectangle (point , point) —> geometry

Result:

A rectangle geometry which side sizes are given by the operands.

Comment:

the center of the rectangle is by default the location of the current agent in which has been called this operator.the center of the rectangle is by default the location of the current agent in which has been called this operator.

Special cases:

returns nil if the operand is nil.
returns nil if the operand is nil.
returns nil if the operand is nil.

Examples:

geometry var0 <- rectangle(10, 5); 	// var0 equals a geometry as a rectangle with width = 10 and height = 5.
geometry var1 <- rectangle({2.0,6.0}, {6.0,20.0}); 	// var1 equals a geometry as a rectangle with {2.0,6.0} as the upper-left corner, {6.0,20.0} as the lower-right corner.
geometry var2 <- rectangle({10, 5}); 	// var2 equals a geometry as a rectangle with width = 10 and height = 5.

`reduced_by`

Same signification as -

`regression`

Possible use:

regression (any) —> regression

Result:

Casts the operand into the type regression

`remove_duplicates`

Same signification as distinct

`remove_node_from`

Possible use:

geometry remove_node_from graph —> graph
remove_node_from (geometry , graph) —> graph

Result:

removes a node from a graph.

Comment:

all the edges containing this node are also removed.

Examples:

graph var0 <- node(0) remove_node_from graphEpidemio; 	// var0 equals the graph without node(0)

`replace`

Possible use:

replace (string, string, string) —> string

Result:

Returns the String resulting by replacing for the first operand all the sub-strings corresponding the second operand by the third operand

Examples:

string var0 <- replace('to be or not to be,that is the question','to', 'do'); 	// var0 equals 'do be or not do be,that is the question'

`replace_regex`

Possible use:

replace_regex (string, string, string) —> string

Result:

Returns the String resulting by replacing for the first operand all the sub-strings corresponding to the regular expression given in the second operand by the third operand

Examples:

string var0 <- replace_regex("colour, color", "colou?r", "col"); 	// var0 equals 'col, col'

`reverse`

Possible use:

reverse (string) —> string
reverse (container<KeyType,ValueType>) —> msi.gama.util.IContainer<?,?>

Result:

the operand elements in the reversed order in a copy of the operand.

Comment:

the reverse operator behavior depends on the nature of the operand

Special cases:

if it is a file, reverse returns a copy of the file with a reversed content
if it is a population, reverse returns a copy of the population with elements in the reversed order
if it is a graph, reverse returns a copy of the graph (with all edges and vertexes), with all of the edges reversed
if it is a string, reverse returns a new string with characters in the reversed order

string var0 <- reverse ('abcd'); 	// var0 equals 'dcba'

if it is a list, reverse returns a copy of the operand list with elements in the reversed order

msi.gama.util.IContainer<?,?> var1 <- reverse ([10,12,14]); 	// var1 equals [14, 12, 10]

if it is a map, reverse returns a copy of the operand map with each pair in the reversed order (i.e. all keys become values and values become keys)

msi.gama.util.IContainer<?,?> var2 <- reverse (['k1'::44, 'k2'::32, 'k3'::12]); 	// var2 equals [12::'k3',  32::'k2', 44::'k1']

if it is a matrix, reverse returns a new matrix containing the transpose of the operand.

msi.gama.util.IContainer<?,?> var3 <- reverse(matrix([["c11","c12","c13"],["c21","c22","c23"]])); 	// var3 equals matrix([["c11","c21"],["c12","c22"],["c13","c23"]])

`rewire_n`

Possible use:

graph rewire_n int —> graph
rewire_n (graph , int) —> graph

Result:

rewires the given count of edges.

Comment:

If there are too many edges, all the edges will be rewired.

Examples:

graph var1 <- graphEpidemio rewire_n 10; 	// var1 equals the graph with 3 edges rewired

`rgb`

Possible use:

rgb rgb float —> rgb
rgb (rgb , float) —> rgb
rgb rgb int —> rgb
rgb (rgb , int) —> rgb
string rgb int —> rgb
rgb (string , int) —> rgb
rgb (int, int, int) —> rgb
rgb (int, int, int, float) —> rgb
rgb (int, int, int, int) —> rgb

Result:

Returns a color defined by red, green, blue components and an alpha blending value.

Special cases:

It can be used with r=red, g=green, b=blue (each between 0 and 255), a=alpha (between 0.0 and 1.0)
It can be used with a color and an alpha between 0 and 1
It can be used with a color and an alpha between 0 and 255
It can be used with r=red, g=green, b=blue, each between 0 and 255
It can be used with a name of color and alpha (between 0 and 255)
It can be used with r=red, g=green, b=blue (each between 0 and 255), a=alpha (between 0 and 255)

Examples:

rgb var0 <- rgb (255,0,0,0.5); 	// var0 equals a light red color
rgb var1 <- rgb(rgb(255,0,0),0.5); 	// var1 equals a light red color
rgb var2 <- rgb(rgb(255,0,0),125); 	// var2 equals a light red color
rgb var3 <- rgb (255,0,0); 	// var3 equals #red
rgb var4 <- rgb ("red"); 	// var4 equals rgb(255,0,0)
rgb var5 <- rgb (255,0,0,125); 	// var5 equals a light red color

`rgb_to_xyz`

Possible use:

rgb_to_xyz (file) —> list<point>

Result:

A list of point corresponding to RGB value of an image (r:x , g:y, b:z)

Examples:

list<point> var0 <- rgb_to_xyz(texture); 	// var0 equals a list of points

`rnd`

Possible use:

rnd (float) —> float
rnd (int) —> int
rnd (point) —> point
point rnd point —> point
rnd (point , point) —> point
int rnd int —> int
rnd (int , int) —> int
float rnd float —> float
rnd (float , float) —> float
rnd (point, point, float) —> point
rnd (float, float, float) —> float
rnd (int, int, int) —> int

Result:

a random integer in the interval [0, operand]

Comment:

to obtain a probability between 0 and 1, use the expression (rnd n) / n, where n is used to indicate the precision

Special cases:

if the operand is a float, returns an uniformly distributed float random number in [0.0, to]
if the operand is a point, returns a point with three random float ordinates, each in the interval [0, ordinate of argument]

Examples:

float var0 <- rnd(3.4); 	// var0 equals a random float between 0.0 and 3.4
point var1 <- rnd ({2.0, 4.0}, {2.0, 5.0, 10.0}, 1); 	// var1 equals a point with x = 2.0, y equal to 2.0, 3.0 or 4.0 and z between 0.0 and 10.0 every 1.0
point var2 <- rnd ({2.0, 4.0}, {2.0, 5.0, 10.0}); 	// var2 equals a point with x = 2.0, y between 2.0 and 4.0 and z between 0.0 and 10.0
int var3 <- rnd (2, 4); 	// var3 equals 2, 3 or 4
float var4 <- rnd (2.0, 4.0); 	// var4 equals a float number between 2.0 and 4.0
float var5 <- rnd (2.0, 4.0, 0.5); 	// var5 equals a float number between 2.0 and 4.0 every 0.5
int var6 <- rnd (2); 	// var6 equals 0, 1 or 2
float var7 <- rnd (1000) / 1000; 	// var7 equals a float between 0 and 1 with a precision of 0.001
point var8 <- rnd ({2.5,3, 0.0}); 	// var8 equals {x,y} with x in [0.0,2.0], y in [0.0,3.0], z = 0.0
int var9 <- rnd (2, 12, 4); 	// var9 equals 2, 6 or 10

`rnd_choice`

Possible use:

rnd_choice (container) —> int

Result:

returns an index of the given list with a probability following the (normalized) distribution described in the list (a form of lottery)

Examples:

int var0 <- rnd_choice([0.2,0.5,0.3]); 	// var0 equals 2/10 chances to return 0, 5/10 chances to return 1, 3/10 chances to return 2

`rnd_color`

Possible use:

rnd_color (int) —> rgb

Result:

rgb color

Comment:

Return a random color equivalent to rgb(rnd(operand),rnd(operand),rnd(operand))

Examples:

rgb var0 <- rnd_color(255); 	// var0 equals a random color, equivalent to rgb(rnd(255),rnd(255),rnd(255))

`rotated_by`

Possible use:

geometry rotated_by float —> geometry
rotated_by (geometry , float) —> geometry
geometry rotated_by int —> geometry
rotated_by (geometry , int) —> geometry
rotated_by (geometry, float, point) —> geometry

Result:

A geometry resulting from the application of a rotation by the right-hand operand angle (degree) to the left-hand operand (geometry, agent, point) A geometry resulting from the application of a rotation by the right-hand operand angles (degree) along the three axis (x,y,z) to the left-hand operand (geometry, agent, point)

Comment:

the right-hand operand can be a float or a int

Examples:

geometry var0 <- self rotated_by 45; 	// var0 equals the geometry resulting from a 45 degrees rotation to the geometry of the agent applying the operator.
geometry var1 <- rotated_by(pyramid(10),45, {1,0,0}); 	// var1 equals the geometry resulting from a 45 degrees rotation along the {1,0,0} vector to the geometry of the agent applying the operator.

`round`

Possible use:

round (int) —> int
round (point) —> point
round (float) —> int

Result:

Returns the rounded value of the operand.

Special cases:

if the operand is an int, round returns it

Examples:

point var0 <- {12345.78943,  12345.78943, 12345.78943} with_precision 2; 	// var0 equals {12345.79,12345.79,12345.79}
int var1 <- round (0.51); 	// var1 equals 1
int var2 <- round (100.2); 	// var2 equals 100
int var3 <- round(-0.51); 	// var3 equals -1

`row_at`

Possible use:

matrix row_at int —> list
row_at (matrix , int) —> list

Result:

returns the row at a num_line (right-hand operand)

Examples:

list var0 <- matrix([["el11","el12","el13"],["el21","el22","el23"],["el31","el32","el33"]]) row_at 2; 	// var0 equals ["el13","el23","el33"]

`rows_list`

Possible use:

rows_list (matrix) —> list<list>

Result:

returns a list of the rows of the matrix, with each row as a list of elements

Examples:

list<list> var0 <- rows_list(matrix([["el11","el12","el13"],["el21","el22","el23"],["el31","el32","el33"]])); 	// var0 equals [["el11","el21","el31"],["el12","el22","el32"],["el13","el23","el33"]]

`sample`

Possible use:

sample (any expression) —> string
string sample any expression —> string
sample (string , any expression) —> string
sample (container, int, bool) —> container
sample (container, int, bool, container) —> container

Result:

takes a sample of the specified size from the elements of x using either with or without replacement takes a sample of the specified size from the elements of x using either with or without replacement with given weights

Examples:

container var0 <- sample([2,10,1],2,false); 	// var0 equals [1,2]
container var1 <- sample([2,10,1],2,false,[0.1,0.7,0.2]); 	// var1 equals [10,2]

`scaled_by`

Same signification as [](#)

`scaled_to`

Possible use:

geometry scaled_to point —> geometry
scaled_to (geometry , point) —> geometry

Result:

allows to restrict the size of a geometry so that it fits in the envelope {width, height, depth} defined by the second operand

Examples:

geometry var0 <- shape scaled_to {10,10}; 	// var0 equals a geometry corresponding to the geometry of the agent applying the operator scaled so that it fits a square of 10x10

`select`

Same signification as where

`set_about`

Possible use:

emotion set_about predicate —> emotion
set_about (emotion , predicate) —> emotion

Result:

change the about value of the given emotion

Examples:

emotion set_about predicate1

`set_agent`

Possible use:

msi.gaml.architecture.simplebdi.SocialLink set_agent agent —> msi.gaml.architecture.simplebdi.SocialLink
set_agent (msi.gaml.architecture.simplebdi.SocialLink , agent) —> msi.gaml.architecture.simplebdi.SocialLink

Result:

change the agent value of the given social link

Examples:

social_link set_agent agentA

`set_agent_cause`

Possible use:

emotion set_agent_cause agent —> emotion
set_agent_cause (emotion , agent) —> emotion
predicate set_agent_cause agent —> predicate
set_agent_cause (predicate , agent) —> predicate

Result:

change the agentCause value of the given emotion change the agentCause value of the given predicate

Examples:

emotion set_agent_cause agentA
predicate set_agent_cause agentA

`set_decay`

Possible use:

emotion set_decay float —> emotion
set_decay (emotion , float) —> emotion

Result:

change the decay value of the given emotion

Examples:

emotion set_decay 12

`set_dominance`

Possible use:

msi.gaml.architecture.simplebdi.SocialLink set_dominance float —> msi.gaml.architecture.simplebdi.SocialLink
set_dominance (msi.gaml.architecture.simplebdi.SocialLink , float) —> msi.gaml.architecture.simplebdi.SocialLink

Result:

change the dominance value of the given social link

Examples:

social_link set_dominance 0.4

`set_familiarity`

Possible use:

msi.gaml.architecture.simplebdi.SocialLink set_familiarity float —> msi.gaml.architecture.simplebdi.SocialLink
set_familiarity (msi.gaml.architecture.simplebdi.SocialLink , float) —> msi.gaml.architecture.simplebdi.SocialLink

Result:

change the familiarity value of the given social link

Examples:

social_link set_familiarity 0.4

`set_intensity`

Possible use:

emotion set_intensity float —> emotion
set_intensity (emotion , float) —> emotion

Result:

change the intensity value of the given emotion

Examples:

emotion set_intensity 12

`set_liking`

Possible use:

msi.gaml.architecture.simplebdi.SocialLink set_liking float —> msi.gaml.architecture.simplebdi.SocialLink
set_liking (msi.gaml.architecture.simplebdi.SocialLink , float) —> msi.gaml.architecture.simplebdi.SocialLink

Result:

change the liking value of the given social link

Examples:

social_link set_liking 0.4

`set_solidarity`

Possible use:

msi.gaml.architecture.simplebdi.SocialLink set_solidarity float —> msi.gaml.architecture.simplebdi.SocialLink
set_solidarity (msi.gaml.architecture.simplebdi.SocialLink , float) —> msi.gaml.architecture.simplebdi.SocialLink

Result:

change the solidarity value of the given social link

Examples:

social_link set_solidarity 0.4

`set_truth`

Possible use:

predicate set_truth bool —> predicate
set_truth (predicate , bool) —> predicate

Result:

change the is_true value of the given predicate

Examples:

predicate set_truth false

`set_z`

Possible use:

geometry set_z container<float> —> geometry
set_z (geometry , container<float>) —> geometry
set_z (geometry, int, float) —> geometry

Result:

Sets the z ordinate of the n-th point of a geometry to the value provided by the third argument

Examples:

loop i from: 0 to: length(shape.points) - 1{set shape <-  set_z (shape, i, 3.0);}
shape <- triangle(3) set_z [5,10,14];

`shape_file`

Possible use:

shape_file (string) —> file

Result:

Constructs a file of type shape. Allowed extensions are limited to shp

`shuffle`

Possible use:

shuffle (matrix) —> matrix
shuffle (string) —> string
shuffle (container) —> container

Result:

The elements of the operand in random order.

Special cases:

if the operand is empty, returns an empty list (or string, matrix)

Examples:

matrix var0 <- shuffle (matrix([["c11","c12","c13"],["c21","c22","c23"]])); 	// var0 equals matrix([["c12","c21","c11"],["c13","c22","c23"]]) (for example)
string var1 <- shuffle ('abc'); 	// var1 equals 'bac' (for example)
container var2 <- shuffle ([12, 13, 14]); 	// var2 equals [14,12,13] (for example)

`signum`

Possible use:

signum (float) —> int

Result:

Returns -1 if the argument is negative, +1 if it is positive, 0 if it is equal to zero or not a number

Examples:

int var0 <- signum(-12); 	// var0 equals -1
int var1 <- signum(14); 	// var1 equals 1
int var2 <- signum(0); 	// var2 equals 0

`simple_clustering_by_distance`

Possible use:

container<agent> simple_clustering_by_distance float —> list<list<agent>>
simple_clustering_by_distance (container<agent> , float) —> list<list<agent>>

Result:

A list of agent groups clustered by distance considering a distance min between two groups.

Examples:

list<list<agent>> var0 <- [ag1, ag2, ag3, ag4, ag5] simpleClusteringByDistance 20.0; 	// var0 equals for example, can return [[ag1, ag3], [ag2], [ag4, ag5]]

`simple_clustering_by_envelope_distance`

Same signification as simple_clustering_by_distance

`simplification`

Possible use:

geometry simplification float —> geometry
simplification (geometry , float) —> geometry

Result:

A geometry corresponding to the simplification of the operand (geometry, agent, point) considering a tolerance distance.

Comment:

The algorithm used for the simplification is Douglas-Peucker

Examples:

geometry var0 <- self simplification 0.1; 	// var0 equals the geometry resulting from the application of the Douglas-Peuker algorithm on the geometry of the agent applying the operator with a tolerance distance of 0.1.

`sin`

Possible use:

sin (float) —> float
sin (int) —> float

Result:

Returns the value (in [-1,1]) of the sinus of the operand (in decimal degrees). The argument is casted to an int before being evaluated.

Special cases:

Operand values out of the range [0-359] are normalized.

Examples:

float var0 <- sin(360); 	// var0 equals 0.0
float var1 <- sin (0); 	// var1 equals 0.0

`sin_rad`

Possible use:

sin_rad (float) —> float

Result:

Returns the value (in [-1,1]) of the sinus of the operand (in decimal degrees). The argument is casted to an int before being evaluated.

Special cases:

Operand values out of the range [0-359] are normalized.

Examples:

float var0 <- sin(360); 	// var0 equals 0.0

`since`

Possible use:

since (date) —> bool
any expression since date —> bool
since (any expression , date) —> bool

Result:

Returns true if the current_date of the model is after (or equal to) the date passed in argument. Synonym of ‘current_date >= argument’. Can be used, like ‘after’, in its composed form with 2 arguments to express the lowest boundary of the computation of a frequency. However, contrary to ‘after’, there is a subtle difference: the lowest boundary will be tested against the frequency as well

Examples:

reflex when: since(starting_date) {} -: will always be run
every(2#days) since (starting_date + 1#day) // the computation will return true 1 day after the starting date and every two days after this reference date

`skeletonize`

Possible use:

skeletonize (geometry) —> list<geometry>

Result:

A list of geometries (polylines) corresponding to the skeleton of the operand geometry (geometry, agent)

Examples:

list<geometry> var0 <- skeletonize(self); 	// var0 equals the list of geometries corresponding to the skeleton of the geometry of the agent applying the operator.

`skew_gauss`

Possible use:

skew_gauss (float, float, float, float) —> float

Result:

A value from a skew normally distributed random variable with min value (the minimum skewed value possible), max value (the maximum skewed value possible), skew (the degree to which the values cluster around the mode of the distribution; higher values mean tighter clustering) and bias (the tendency of the mode to approach the min, max or midpoint value; positive values bias toward max, negative values toward min).The algorithm was taken from http://stackoverflow.com/questions/5853187/skewing-java-random-number-generation-toward-a-certain-number

Examples:

float var0 <- skew_gauss(0.0, 1.0, 0.7,0.1); 	// var0 equals 0.1729218460343077

`skewness`

Possible use:

skewness (list) —> float

Result:

returns skewness value computed from the operand list of values

Special cases:

if the length of the list is lower than 3, returns NaN

Examples:

skewness ([1,2,3,4,5])

`skill`

Possible use:

skill (any) —> skill

Result:

Casts the operand into the type skill

`smooth`

Possible use:

geometry smooth float —> geometry
smooth (geometry , float) —> geometry

Result:

Returns a ‘smoothed’ geometry, where straight lines are replaces by polynomial (bicubic) curves. The first parameter is the original geometry, the second is the ‘fit’ parameter which can be in the range 0 (loose fit) to 1 (tightest fit).

Examples:

geometry var0 <- smooth(square(10), 0.0); 	// var0 equals a 'rounded' square

`social_link`

Possible use:

social_link (any) —> social_link

Result:

Casts the operand into the type social_link

`solid`

Same signification as without_holes

`sort`

Same signification as sort_by

`sort_by`

Possible use:

container sort_by any expression —> container
sort_by (container , any expression) —> container

Result:

Returns a list, containing the elements of the left-hand operand sorted in ascending order by the value of the right-hand operand when it is evaluated on them.

Comment:

the left-hand operand is casted to a list before applying the operator. In the right-hand operand, the keyword each can be used to represent, in turn, each of the elements.

Special cases:

if the left-hand operand is nil, sort_by throws an error

Examples:

container var0 <- [1,2,4,3,5,7,6,8] sort_by (each); 	// var0 equals [1,2,3,4,5,6,7,8]
container var2 <- g2 sort_by (length(g2 out_edges_of each) ); 	// var2 equals [node9, node7, node10, node8, node11, node6, node5, node4]
container var3 <- (list(node) sort_by (round(node(each).location.x)); 	// var3 equals [node5, node1, node0, node2, node3]
container var4 <- [1::2, 5::6, 3::4] sort_by (each); 	// var4 equals [2, 4, 6]

`source_of`

Possible use:

graph source_of unknown —> unknown
source_of (graph , unknown) —> unknown

Result:

returns the source of the edge (right-hand operand) contained in the graph given in left-hand operand.

Special cases:

if the lef-hand operand (the graph) is nil, throws an Exception

Examples:

graph graphEpidemio <- generate_barabasi_albert( ["edges_species"::edge,"vertices_specy"::node,"size"::3,"m"::5] );
unknown var1 <- graphEpidemio source_of(edge(3)); 	// var1 equals node1
graph graphFromMap <-  as_edge_graph([{1,5}::{12,45},{12,45}::{34,56}]);
point var3 <- graphFromMap source_of(link({1,5}::{12,45})); 	// var3 equals {1,5}

`spatial_graph`

Possible use:

spatial_graph (container) —> graph

Result:

allows to create a spatial graph from a container of vertices, without trying to wire them. The container can be empty. Emits an error if the contents of the container are not geometries, points or agents

`species`

Possible use:

species (unknown) —> species

Result:

casting of the operand to a species.

Special cases:

if the operand is nil, returns nil;
if the operand is an agent, returns its species;
if the operand is a string, returns the species with this name (nil if not found);
otherwise, returns nil

Examples:

species var0 <- species(self); 	// var0 equals the species of the current agent
species var1 <- species('node'); 	// var1 equals node
species var2 <- species([1,5,9,3]); 	// var2 equals nil
species var3 <- species(node1); 	// var3 equals node

`species_of`

Same signification as species

`sphere`

Possible use:

sphere (float) —> geometry

Result:

A sphere geometry which radius is equal to the operand.

Comment:

the centre of the sphere is by default the location of the current agent in which has been called this operator.

Special cases:

returns a point if the operand is lower or equal to 0.

Examples:

geometry var0 <- sphere(10); 	// var0 equals a geometry as a circle of radius 10 but displays a sphere.

`split_at`

Possible use:

geometry split_at point —> list<geometry>
split_at (geometry , point) —> list<geometry>

Result:

The two part of the left-operand lines split at the given right-operand point

Special cases:

if the left-operand is a point or a polygon, returns an empty list

Examples:

list<geometry> var0 <- polyline([{1,2},{4,6}]) split_at {7,6}; 	// var0 equals [polyline([{1.0,2.0},{7.0,6.0}]), polyline([{7.0,6.0},{4.0,6.0}])]

`split_geometry`

Possible use:

geometry split_geometry float —> list<geometry>
split_geometry (geometry , float) —> list<geometry>
geometry split_geometry point —> list<geometry>
split_geometry (geometry , point) —> list<geometry>
split_geometry (geometry, int, int) —> list<geometry>

Result:

A list of geometries that result from the decomposition of the geometry by square cells of the given side size (geometry, size) A list of geometries that result from the decomposition of the geometry by rectangle cells of the given dimension (geometry, {size_x, size_y}) A list of geometries that result from the decomposition of the geometry according to a grid with the given number of rows and columns (geometry, nb_cols, nb_rows)

Examples:

list<geometry> var0 <- to_squares(self, 10.0); 	// var0 equals the list of the geometries corresponding to the decomposition of the geometry by squares of side size 10.0
list<geometry> var1 <- to_rectangles(self, {10.0, 15.0}); 	// var1 equals the list of the geometries corresponding to the decomposition of the geometry by rectangles of size 10.0, 15.0
list<geometry> var2 <- to_rectangles(self, 10,20); 	// var2 equals the list of the geometries corresponding to the decomposition of the geometry of the agent applying the operator

`split_lines`

Possible use:

split_lines (container<geometry>) —> list<geometry>

Result:

A list of geometries resulting after cutting the lines at their intersections.

Examples:

list<geometry> var0 <- split_lines([line([{0,10}, {20,10}]), line([{0,10}, {20,10}])]); 	// var0 equals a list of four polylines: line([{0,10}, {10,10}]), line([{10,10}, {20,10}]), line([{10,0}, {10,10}]) and line([{10,10}, {10,20}])

`split_with`

Possible use:

string split_with string —> container
split_with (string , string) —> container

Result:

Returns a list containing the sub-strings (tokens) of the left-hand operand delimited by each of the characters of the right-hand operand.

Comment:

Delimiters themselves are excluded from the resulting list.

Examples:

container var0 <- 'to be or not to be,that is the question' split_with ' ,'; 	// var0 equals ['to','be','or','not','to','be','that','is','the','question']

`sqrt`

Possible use:

sqrt (int) —> float
sqrt (float) —> float

Result:

Returns the square root of the operand.

Special cases:

if the operand is negative, an exception is raised

Examples:

float var0 <- sqrt(4); 	// var0 equals 2.0
float var1 <- sqrt(4); 	// var1 equals 2.0

`square`

Possible use:

square (float) —> geometry

Result:

A square geometry which side size is equal to the operand.

Comment:

the centre of the square is by default the location of the current agent in which has been called this operator.

Special cases:

returns nil if the operand is nil.

Examples:

geometry var0 <- square(10); 	// var0 equals a geometry as a square of side size 10.

`squircle`

Possible use:

float squircle float —> geometry
squircle (float , float) —> geometry

Result:

A mix of square and circle geometry (see : http://en.wikipedia.org/wiki/Squircle), which side size is equal to the first operand and power is equal to the second operand

Comment:

the center of the ellipse is by default the location of the current agent in which has been called this operator.

Special cases:

returns a point if the side operand is lower or equal to 0.

Examples:

geometry var0 <- squircle(4,4); 	// var0 equals a geometry as a squircle of side 4 with a power of 4.

`standard_deviation`

Possible use:

standard_deviation (container) —> float

Result:

the standard deviation on the elements of the operand. See Standard_deviation for more details.

Comment:

The operator casts all the numerical element of the list into float. The elements that are not numerical are discarded.

Examples:

float var0 <- standard_deviation ([4.5, 3.5, 5.5, 7.0]); 	// var0 equals 1.2930100540985752

`string`

Possible use:

date string string —> string
string (date , string) —> string

Result:

converts a date to astring following a custom pattern. The pattern can use “%Y %M %N %D %E %h %m %s %z” for outputting years, months, name of month, days, name of days, hours, minutes, seconds and the time-zone. A null or empty pattern will return the complete date as defined by the ISO date & time format. The pattern can also follow the pattern definition found here, which gives much more control over the format of the date: https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html#patterns. Different patterns are available by default as constants: #iso_local, #iso_simple, #iso_offset, #iso_zoned and #custom, which can be changed in the preferences

Examples:

format(#now, 'yyyy-MM-dd')

`subtract_days`

Same signification as minus_days

`subtract_hours`

Same signification as minus_hours

`subtract_minutes`

Same signification as minus_minutes

`subtract_months`

Same signification as minus_months

`subtract_ms`

Same signification as minus_ms

`subtract_seconds`

Same signification as -

`subtract_weeks`

Same signification as minus_weeks

`subtract_years`

Same signification as minus_years

`successors_of`

Possible use:

graph successors_of unknown —> container
successors_of (graph , unknown) —> container

Result:

returns the list of successors (i.e. targets of out edges) of the given vertex (right-hand operand) in the given graph (left-hand operand)

Examples:

container var1 <- graphEpidemio successors_of ({1,5}); 	// var1 equals [{12,45}]
container var2 <- graphEpidemio successors_of node({34,56}); 	// var2 equals []

`sum`

Possible use:

sum (graph) —> float
sum (container) —> unknown

Result:

the sum of all the elements of the operand

Comment:

the behavior depends on the nature of the operand

Special cases:

if it is a population or a list of other types: sum transforms all elements into float and sums them
if it is a map, sum returns the sum of the value of all elements
if it is a file, sum returns the sum of the content of the file (that is also a container)
if it is a graph, sum returns the total weight of the graph
if it is a matrix of int, float or object, sum returns the sum of all the numerical elements (i.e. all elements for integer and float matrices)
if it is a matrix of other types: sum transforms all elements into float and sums them
if it is a list of colors: sum will sum them and return the blended resulting color
if it is a list of int or float: sum returns the sum of all the elements

int var0 <- sum ([12,10,3]); 	// var0 equals 25

if it is a list of points: sum returns the sum of all points as a point (each coordinate is the sum of the corresponding coordinate of each element)

unknown var1 <- sum([{1.0,3.0},{3.0,5.0},{9.0,1.0},{7.0,8.0}]); 	// var1 equals {20.0,17.0}

`sum_of`

Possible use:

container sum_of any expression —> unknown
sum_of (container , any expression) —> unknown

Result:

the sum of the right-hand expression evaluated on each of the elements of the left-hand operand

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

if the left-operand is a map, the keyword each will contain each value

unknown var2 <- [1::2, 3::4, 5::6] sum_of (each + 3); 	// var2 equals 21

Examples:

unknown var1 <- [1,2] sum_of (each * 100 ); 	// var1 equals 300

`svg_file`

Possible use:

svg_file (string) —> file

Result:

Constructs a file of type svg. Allowed extensions are limited to svg

`tan`

Possible use:

tan (int) —> float
tan (float) —> float

Result:

Returns the value (in [-1,1]) of the trigonometric tangent of the operand (in decimal degrees). The argument is casted to an int before being evaluated.

Special cases:

Operand values out of the range [0-359] are normalized. Notice that tan(360) does not return 0.0 but -2.4492935982947064E-16
The tangent is only defined for any real number except 90 + k * 180 (k an positive or negative integer). Nevertheless notice that tan(90) returns 1.633123935319537E16 (whereas we could except infinity).

Examples:

float var0 <- tan (0); 	// var0 equals 0.0
float var1 <- tan(90); 	// var1 equals 1.633123935319537E16

`tan_rad`

Possible use:

tan_rad (float) —> float

Result:

Returns the value (in [-1,1]) of the trigonometric tangent of the operand (in decimal degrees). The argument is casted to an int before being evaluated.

Special cases:

Operand values out of the range [0-359] are normalized. Notice that tan(360) does not return 0.0 but -2.4492935982947064E-16
The tangent is only defined for any real number except 90 + k * 180 (k an positive or negative integer). Nevertheless notice that tan(90) returns 1.633123935319537E16 (whereas we could except infinity).

`tanh`

Possible use:

tanh (float) —> float
tanh (int) —> float

Result:

Returns the value (in the interval [-1,1]) of the hyperbolic tangent of the operand (which can be any real number, expressed in decimal degrees).

Examples:

float var0 <- tanh(0); 	// var0 equals 0.0
float var1 <- tanh(100); 	// var1 equals 1.0

`target_of`

Possible use:

graph target_of unknown —> unknown
target_of (graph , unknown) —> unknown

Result:

returns the target of the edge (right-hand operand) contained in the graph given in left-hand operand.

Special cases:

if the lef-hand operand (the graph) is nil, returns nil

Examples:

graph graphEpidemio <- generate_barabasi_albert( ["edges_species"::edge,"vertices_specy"::node,"size"::3,"m"::5] );
unknown var1 <- graphEpidemio source_of(edge(3)); 	// var1 equals node1
graph graphFromMap <-  as_edge_graph([{1,5}::{12,45},{12,45}::{34,56}]);
unknown var3 <- graphFromMap target_of(link({1,5}::{12,45})); 	// var3 equals {12,45}

`teapot`

Possible use:

teapot (float) —> geometry

Result:

A teapot geometry which radius is equal to the operand.

Comment:

the centre of the teapot is by default the location of the current agent in which has been called this operator.

Special cases:

returns a point if the operand is lower or equal to 0.

Examples:

geometry var0 <- teapot(10); 	// var0 equals a geometry as a circle of radius 10 but displays a teapot.

`text_file`

Possible use:

text_file (string) —> file

Result:

Constructs a file of type text. Allowed extensions are limited to txt, data, text

`TGauss`

Same signification as truncated_gauss

`threeds_file`

Possible use:

threeds_file (string) —> file

Result:

Constructs a file of type threeds. Allowed extensions are limited to 3ds, max

`to`

Possible use:

date to date —> msi.gama.util.IList<msi.gama.util.GamaDate>
to (date , date) —> msi.gama.util.IList<msi.gama.util.GamaDate>

Result:

builds an interval between two dates (the first inclusive and the second exclusive, which behaves like a read-only list of dates. The default step between two dates is the step of the model

Comment:

The default step can be overruled by using the every operator applied to this interval

Examples:

date('2000-01-01') to date('2010-01-01') // builds an interval between these two dates
(date('2000-01-01') to date('2010-01-01')) every (#month) // builds an interval between these two dates which contains all the monthly dates starting from the beginning of the interval

`to_GAMA_CRS`

Possible use:

to_GAMA_CRS (geometry) —> geometry
geometry to_GAMA_CRS string —> geometry
to_GAMA_CRS (geometry , string) —> geometry

Special cases:

returns the geometry corresponding to the transformation of the given geometry to the GAMA CRS (Coordinate Reference System) assuming the given geometry is referenced by given CRS

geometry var0 <- to_GAMA_CRS({121,14}, "EPSG:4326"); 	// var0 equals a geometry corresponding to the agent geometry transformed into the GAMA CRS

returns the geometry corresponding to the transformation of the given geometry to the GAMA CRS (Coordinate Reference System) assuming the given geometry is referenced by the current CRS, the one corresponding to the world’s agent one

geometry var1 <- to_GAMA_CRS({121,14}); 	// var1 equals a geometry corresponding to the agent geometry transformed into the GAMA CRS

`to_gaml`

Possible use:

to_gaml (unknown) —> string

Result:

returns the literal description of an expression or description – action, behavior, species, aspect, even model – in gaml

Examples:

string var0 <- to_gaml(0); 	// var0 equals '0'
string var1 <- to_gaml(3.78); 	// var1 equals '3.78'
string var2 <- to_gaml(true); 	// var2 equals 'true'
string var3 <- to_gaml({23, 4.0}); 	// var3 equals '{23.0,4.0,0.0}'
string var4 <- to_gaml(5::34); 	// var4 equals '5::34'
string var5 <- to_gaml(rgb(255,0,125)); 	// var5 equals 'rgb (255, 0, 125,255)'
string var6 <- to_gaml('hello'); 	// var6 equals "'hello'"
string var7 <- to_gaml([1,5,9,3]); 	// var7 equals '[1,5,9,3]'
string var8 <- to_gaml(['a'::345, 'b'::13, 'c'::12]); 	// var8 equals "(['a'::345,'b'::13,'c'::12] as map )"
string var9 <- to_gaml([[3,5,7,9],[2,4,6,8]]); 	// var9 equals '[[3,5,7,9],[2,4,6,8]]'
string var10 <- to_gaml(a_graph); 	// var10 equals ([((1 as node)::(3 as node))::(5 as edge),((0 as node)::(3 as node))::(3 as edge),((1 as node)::(2 as node))::(1 as edge),((0 as node)::(2 as node))::(2 as edge),((0 as node)::(1 as node))::(0 as edge),((2 as node)::(3 as node))::(4 as edge)] as map ) as graph
string var11 <- to_gaml(node1); 	// var11 equals  1 as node

`to_rectangles`

Possible use:

to_rectangles (geometry, point, bool) —> list<geometry>
to_rectangles (geometry, int, int, bool) —> list<geometry>

Result:

A list of rectangles of the size corresponding to the given dimension that result from the decomposition of the geometry into rectangles (geometry, dimension, overlaps), if overlaps = true, add the rectangles that overlap the border of the geometry A list of rectangles corresponding to the given dimension that result from the decomposition of the geometry into rectangles (geometry, nb_cols, nb_rows, overlaps) by a grid composed of the given number of columns and rows, if overlaps = true, add the rectangles that overlap the border of the geometry

Examples:

list<geometry> var0 <- to_rectangles(self, {10.0, 15.0}, true); 	// var0 equals the list of rectangles of size {10.0, 15.0} corresponding to the discretization into rectangles of the geometry of the agent applying the operator. The rectangles overlapping the border of the geometry are kept
list<geometry> var1 <- to_rectangles(self, 5, 20, true); 	// var1 equals the list of rectangles corresponding to the discretization by a grid of 5 columns and 20 rows into rectangles of the geometry of the agent applying the operator. The rectangles overlapping the border of the geometry are kept

`to_squares`

Same signification as split_geometry

Possible use:

to_squares (geometry, int, bool) —> list<geometry>
to_squares (geometry, float, bool) —> list<geometry>
to_squares (geometry, int, bool, float) —> list<geometry>

Result:

A list of a given number of squares from the decomposition of the geometry into squares (geometry, nb_square, overlaps), if overlaps = true, add the squares that overlap the border of the geometry A list of squares of the size corresponding to the given size that result from the decomposition of the geometry into squares (geometry, size, overlaps), if overlaps = true, add the squares that overlap the border of the geometry A list of a given number of squares from the decomposition of the geometry into squares (geometry, nb_square, overlaps, precision_coefficient), if overlaps = true, add the squares that overlap the border of the geometry, coefficient_precision should be close to 1.0

Examples:

list<geometry> var0 <- to_squares(self, 10, true); 	// var0 equals the list of 10 squares corresponding to the discretization into squares of the geometry of the agent applying the operator. The squares overlapping the border of the geometry are kept
list<geometry> var1 <- to_squares(self, 10.0, true); 	// var1 equals the list of squares of side size 10.0 corresponding to the discretization into squares of the geometry of the agent applying the operator. The squares overlapping the border of the geometry are kept
list<geometry> var2 <- to_squares(self, 10, true, 0.99); 	// var2 equals the list of 10 squares corresponding to the discretization into squares of the geometry of the agent applying the operator. The squares overlapping the border of the geometry are kept

`to_triangles`

Same signification as triangulate

`tokenize`

Same signification as split_with

`topology`

Possible use:

topology (unknown) —> topology

Result:

casting of the operand to a topology.

Special cases:

if the operand is a topology, returns the topology itself;
if the operand is a spatial graph, returns the graph topology associated;
if the operand is a population, returns the topology of the population;
if the operand is a shape or a geometry, returns the continuous topology bounded by the geometry;
if the operand is a matrix, returns the grid topology associated
if the operand is another kind of container, returns the multiple topology associated to the container
otherwise, casts the operand to a geometry and build a topology from it.

Examples:

topology var0 <- topology(0); 	// var0 equals nil
topology(a_graph)	--: Multiple topology in POLYGON ((24.712119771887785 7.867357373616512, 24.712119771887785 61.283226839310565, 82.4013676510046  7.867357373616512)) at location[53.556743711446195;34.57529210646354]

`touches`

Possible use:

geometry touches geometry —> bool
touches (geometry , geometry) —> bool

Result:

A boolean, equal to true if the left-geometry (or agent/point) touches the right-geometry (or agent/point).

Comment:

returns true when the left-operand only touches the right-operand. When one geometry covers partially (or fully) the other one, it returns false.

Special cases:

if one of the operand is null, returns false.

Examples:

bool var0 <- polyline([{10,10},{20,20}]) touches {15,15}; 	// var0 equals false
bool var1 <- polyline([{10,10},{20,20}]) touches {10,10}; 	// var1 equals true
bool var2 <- {15,15} touches {15,15}; 	// var2 equals false
bool var3 <- polyline([{10,10},{20,20}]) touches polyline([{10,10},{5,5}]); 	// var3 equals true
bool var4 <- polyline([{10,10},{20,20}]) touches polyline([{5,5},{15,15}]); 	// var4 equals false
bool var5 <- polyline([{10,10},{20,20}]) touches polyline([{15,15},{25,25}]); 	// var5 equals false
bool var6 <- polygon([{10,10},{10,20},{20,20},{20,10}]) touches polygon([{15,15},{15,25},{25,25},{25,15}]); 	// var6 equals false
bool var7 <- polygon([{10,10},{10,20},{20,20},{20,10}]) touches polygon([{10,20},{20,20},{20,30},{10,30}]); 	// var7 equals true
bool var8 <- polygon([{10,10},{10,20},{20,20},{20,10}]) touches polygon([{10,10},{0,10},{0,0},{10,0}]); 	// var8 equals true
bool var9 <- polygon([{10,10},{10,20},{20,20},{20,10}]) touches {15,15}; 	// var9 equals false
bool var10 <- polygon([{10,10},{10,20},{20,20},{20,10}]) touches {10,15}; 	// var10 equals true

`towards`

Possible use:

geometry towards geometry —> int
towards (geometry , geometry) —> int

Result:

The direction (in degree) between the two geometries (geometries, agents, points) considering the topology of the agent applying the operator.

Examples:

int var0 <- ag1 towards ag2; 	// var0 equals the direction between ag1 and ag2 and ag3 considering the topology of the agent applying the operator

`trace`

Possible use:

trace (matrix) —> float

Result:

The trace of the given matrix (the sum of the elements on the main diagonal).

Examples:

float var0 <- trace(matrix([[1,2],[3,4]])); 	// var0 equals 5

`transformed_by`

Possible use:

geometry transformed_by point —> geometry
transformed_by (geometry , point) —> geometry

Result:

A geometry resulting from the application of a rotation and a scaling (right-operand : point {angle(degree), scale factor} of the left-hand operand (geometry, agent, point)

Examples:

geometry var0 <- self transformed_by {45, 0.5}; 	// var0 equals the geometry resulting from 45 degrees rotation and 50% scaling of the geometry of the agent applying the operator.

`translated_by`

Possible use:

geometry translated_by point —> geometry
translated_by (geometry , point) —> geometry

Result:

A geometry resulting from the application of a translation by the right-hand operand distance to the left-hand operand (geometry, agent, point)

Examples:

geometry var0 <- self translated_by {10,10,10}; 	// var0 equals the geometry resulting from applying the translation to the left-hand geometry (or agent).

`translated_to`

Same signification as at_location

`transpose`

Possible use:

transpose (matrix) —> matrix

Result:

The transposition of the given matrix

Examples:

matrix var0 <- transpose(matrix([[5,-3],[6,-4]])); 	// var0 equals [[5,6],[-3,-4]]

`triangle`

Possible use:

triangle (float) —> geometry

Result:

A triangle geometry which side size is given by the operand.

Comment:

the center of the triangle is by default the location of the current agent in which has been called this operator.

Special cases:

returns nil if the operand is nil.

Examples:

geometry var0 <- triangle(5); 	// var0 equals a geometry as a triangle with side_size = 5.

`triangulate`

Possible use:

triangulate (list<geometry>) —> list<geometry>
triangulate (geometry) —> list<geometry>

Result:

A list of geometries (triangles) corresponding to the Delaunay triangulation of the operand geometry (geometry, agent, point)

Examples:

list<geometry> var0 <- triangulate(self); 	// var0 equals the list of geometries (triangles) corresponding to the Delaunay triangulation of the geometry of the agent applying the operator.
list<geometry> var1 <- triangulate(self); 	// var1 equals the list of geometries (triangles) corresponding to the Delaunay triangulation of the geometry of the agent applying the operator.

`truncated_gauss`

Possible use:

truncated_gauss (container) —> float
truncated_gauss (point) —> float

Result:

A random value from a normally distributed random variable in the interval ]mean - standardDeviation; mean + standardDeviation[.

Special cases:

if the operand is a list, only the two first elements are taken into account as [mean, standardDeviation]
when truncated_gauss is called with a list of only one element mean, it will always return 0.0
when the operand is a point, it is read as {mean, standardDeviation}

Examples:

float var0 <- truncated_gauss ([0.5, 0.0]); 	// var0 equals 0.5
float var1 <- truncated_gauss ({0, 0.3}); 	// var1 equals a float between -0.3 and 0.3

`undirected`

Possible use:

undirected (graph) —> graph

Result:

the operand graph becomes an undirected graph.

Comment:

the operator alters the operand graph, it does not create a new one.

`union`

Possible use:

union (container<geometry>) —> geometry
container union container —> container
union (container , container) —> container

Result:

returns a new list containing all the elements of both containers without duplicated elements.

Special cases:

if the left or right operand is nil, union throws an error
if the right-operand is a container of points, geometries or agents, returns the geometry resulting from the union all the geometries

Examples:

container var0 <- [1,2,3,4,5,6] union [2,4,9]; 	// var0 equals [1,2,3,4,5,6,9]
container var1 <- [1,2,3,4,5,6] union [0,8]; 	// var1 equals [1,2,3,4,5,6,0,8]
container var2 <- [1,3,2,4,5,6,8,5,6] union [0,8]; 	// var2 equals [1,3,2,4,5,6,8,0]
geometry var3 <- union([geom1, geom2, geom3]); 	// var3 equals a geometry corresponding to union between geom1, geom2 and geom3

`unknown`

Possible use:

unknown (any) —> unknown

Result:

Casts the operand into the type unknown

`until`

Possible use:

until (date) —> bool
any expression until date —> bool
until (any expression , date) —> bool

Result:

Returns true if the current_date of the model is before (or equel to) the date passed in argument. Synonym of ‘current_date <= argument’

Examples:

reflex when: until(starting_date) {} -: will be run only once at the beginning of the simulation

`upper_case`

Possible use:

upper_case (string) —> string

Result:

Converts all of the characters in the string operand to upper case

Examples:

string var0 <- upper_case("Abc"); 	// var0 equals 'ABC'

`URL_file`

Possible use:

URL_file (string) —> file

Result:

Constructs a file of type URL. Allowed extensions are limited to url

`use_cache`

Possible use:

graph use_cache bool —> graph
use_cache (graph , bool) —> graph

Result:

if the second operand is true, the operand graph will store in a cache all the previously computed shortest path (the cache be cleared if the graph is modified).

Comment:

the operator alters the operand graph, it does not create a new one.

`user_input`

Possible use:

user_input (any expression) —> map<string,unknown>
string user_input any expression —> map<string,unknown>
user_input (string , any expression) —> map<string,unknown>

Result:

asks the user for some values (not defined as parameters). Takes a string (optional) and a map as arguments. The string is used to specify the message of the dialog box. The map is to specify the parameters you want the user to change before the simulation starts, with the name of the parameter in string key, and the default value as value.

Comment:

This operator takes a map [string::value] as argument, displays a dialog asking the user for these values, and returns the same map with the modified values (if any). The dialog is modal and will interrupt the execution of the simulation until the user has either dismissed or accepted it. It can be used, for instance, in an init section to force the user to input new values instead of relying on the initial values of parameters :

Examples:

map<string,unknown> values2 <- user_input("Enter numer of agents and locations",["Number" :: 100, "Location" :: {10, 10}]);
create bug number: int(values2 at "Number") with: [location:: (point(values2 at "Location"))];
map<string,unknown> values <- user_input(["Number" :: 100, "Location" :: {10, 10}]);
create bug number: int(values at "Number") with: [location:: (point(values at "Location"))];

`using`

Possible use:

any expression using topology —> unknown
using (any expression , topology) —> unknown

Result:

Allows to specify in which topology a spatial computation should take place.

Special cases:

has no effect if the topology passed as a parameter is nil

Examples:

unknown var0 <- (agents closest_to self) using topology(world); 	// var0 equals the closest agent to self (the caller) in the continuous topology of the world

`variance`

Possible use:

variance (container) —> float

Result:

the variance of the elements of the operand. See Variance for more details.

Comment:

The operator casts all the numerical element of the list into float. The elements that are not numerical are discarded.

Examples:

float var0 <- variance ([4.5, 3.5, 5.5, 7.0]); 	// var0 equals 1.671875

`variance_of`

Possible use:

container variance_of any expression —> unknown
variance_of (container , any expression) —> unknown

Result:

the variance of the right-hand expression evaluated on each of the elements of the left-hand operand

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

`voronoi`

Possible use:

voronoi (list<point>) —> list<geometry>
list<point> voronoi geometry —> list<geometry>
voronoi (list<point> , geometry) —> list<geometry>

Result:

A list of geometries corresponding to the Voronoi diagram built from the list of points according to the given clip A list of geometries corresponding to the Voronoi diagram built from the list of points

Examples:

list<geometry> var0 <- voronoi([{10,10},{50,50},{90,90},{10,90},{90,10}], square(300)); 	// var0 equals the list of geometries corresponding to the Voronoi Diagram built from the list of points with a square of 300m side size as clip.
list<geometry> var1 <- voronoi([{10,10},{50,50},{90,90},{10,90},{90,10}]); 	// var1 equals the list of geometries corresponding to the Voronoi Diagram built from the list of points.

`weight_of`

Possible use:

graph weight_of unknown —> float
weight_of (graph , unknown) —> float

Result:

returns the weight of the given edge (right-hand operand) contained in the graph given in right-hand operand.

Comment:

In a localized graph, an edge has a weight by default (the distance between both vertices).

Special cases:

if the left-operand (the graph) is nil, returns nil
if the right-hand operand is not an edge of the given graph, weight_of checks whether it is a node of the graph and tries to return its weight
if the right-hand operand is neither a node, nor an edge, returns 1.

Examples:

graph graphFromMap <-  as_edge_graph([{1,5}::{12,45},{12,45}::{34,56}]);
float var1 <- graphFromMap weight_of(link({1,5}::{12,45})); 	// var1 equals 1.0

`weighted_means_DM`

Possible use:

list<list> weighted_means_DM list<map<string,object>> —> int
weighted_means_DM (list<list> , list<map<string,object>>) —> int

Result:

The index of the candidate that maximizes the weighted mean of its criterion values. The first operand is the list of candidates (a candidate is a list of criterion values); the second operand the list of criterion (list of map)

Special cases:

returns -1 is the list of candidates is nil or empty

Examples:

int var0 <- weighted_means_DM([[1.0, 7.0],[4.0,2.0],[3.0, 3.0]], [["name"::"utility", "weight" :: 2.0],["name"::"price", "weight" :: 1.0]]); 	// var0 equals 1

`where`

Possible use:

container where any expression —> container
where (container , any expression) —> container

Result:

a list containing all the elements of the left-hand operand that make the right-hand operand evaluate to true.

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

if the left-hand operand is a list nil, where returns a new empty list
if the left-operand is a map, the keyword each will contain each value

container var4 <- [1::2, 3::4, 5::6] where (each >= 4); 	// var4 equals [4, 6]

Examples:

container var0 <- [1,2,3,4,5,6,7,8] where (each > 3); 	// var0 equals [4, 5, 6, 7, 8] 
container var2 <- g2 where (length(g2 out_edges_of each) = 0 ); 	// var2 equals [node9, node7, node10, node8, node11]
container var3 <- (list(node) where (round(node(each).location.x) > 32); 	// var3 equals [node2, node3]

`with_lifetime`

Possible use:

predicate with_lifetime int —> predicate
with_lifetime (predicate , int) —> predicate

Result:

change the parameters of the given predicate

Examples:

predicate with_lifetime 10

`with_max_of`

Possible use:

container with_max_of any expression —> unknown
with_max_of (container , any expression) —> unknown

Result:

one of elements of the left-hand operand that maximizes the value of the right-hand operand

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

if the left-hand operand is nil, with_max_of returns the default value of the right-hand operand

Examples:

unknown var0 <- [1,2,3,4,5,6,7,8] with_max_of (each ); 	// var0 equals 8
unknown var2 <- g2 with_max_of (length(g2 out_edges_of each)  ) ; 	// var2 equals node4
unknown var3 <- (list(node) with_max_of (round(node(each).location.x)); 	// var3 equals node3
unknown var4 <- [1::2, 3::4, 5::6] with_max_of (each); 	// var4 equals 6

`with_min_of`

Possible use:

container with_min_of any expression —> unknown
with_min_of (container , any expression) —> unknown

Result:

one of elements of the left-hand operand that minimizes the value of the right-hand operand

Comment:

in the right-hand operand, the keyword each can be used to represent, in turn, each of the right-hand operand elements.

Special cases:

if the left-hand operand is nil, with_max_of returns the default value of the right-hand operand

Examples:

unknown var0 <- [1,2,3,4,5,6,7,8] with_min_of (each ); 	// var0 equals 1
unknown var2 <- g2 with_min_of (length(g2 out_edges_of each)  ); 	// var2 equals node11
unknown var3 <- (list(node) with_min_of (round(node(each).location.x)); 	// var3 equals node0
unknown var4 <- [1::2, 3::4, 5::6] with_min_of (each); 	// var4 equals 2

`with_optimizer_type`

Possible use:

graph with_optimizer_type string —> graph
with_optimizer_type (graph , string) —> graph

Result:

changes the shortest path computation method of the given graph

Comment:

the right-hand operand can be “Djikstra”, “Bellmann”, “Astar” to use the associated algorithm. Note that these methods are dynamic: the path is computed when needed. In contrarily, if the operand is another string, a static method will be used, i.e. all the shortest are previously computed.

Examples:

graphEpidemio <- graphEpidemio with_optimizer_type "static";

`with_praiseworthiness`

Possible use:

predicate with_praiseworthiness float —> predicate
with_praiseworthiness (predicate , float) —> predicate

Result:

change the praiseworthiness value of the given predicate

Examples:

predicate set_truth false

`with_precision`

Possible use:

float with_precision int —> float
with_precision (float , int) —> float
point with_precision int —> point
with_precision (point , int) —> point

Result:

Rounds off the value of left-hand operand to the precision given by the value of right-hand operand Rounds off the ordinates of the left-hand point to the precision given by the value of right-hand operand

Examples:

float var0 <- 12345.78943 with_precision 2; 	// var0 equals 12345.79
float var1 <- 123 with_precision 2; 	// var1 equals 123.00
point var2 <- {12345.78943, 12345.78943, 12345.78943} with_precision 2 ; 	// var2 equals {12345.79, 12345.79, 12345.79}

`with_priority`

Possible use:

predicate with_priority float —> predicate
with_priority (predicate , float) —> predicate

Result:

change the priority of the given predicate

Examples:

predicate with_priority 2

`with_values`

Possible use:

predicate with_values map —> predicate
with_values (predicate , map) —> predicate

Result:

change the parameters of the given predicate

Examples:

predicate with_values ["time"::10]

`with_weights`

Possible use:

graph with_weights map —> graph
with_weights (graph , map) —> graph
graph with_weights container —> graph
with_weights (graph , container) —> graph

Result:

returns the graph (left-hand operand) with weight given in the map (right-hand operand).

Comment:

this operand re-initializes the path finder

Special cases:

if the right-hand operand is a list, affects the n elements of the list to the n first edges. Note that the ordering of edges may change overtime, which can create some problems…
if the left-hand operand is a map, the map should contains pairs such as: vertex/edge::double

graph_from_edges (list(ant) as_map each::one_of (list(ant))) with_weights (list(ant) as_map each::each.food)

`without_holes`

Possible use:

without_holes (geometry) —> geometry

Result:

A geometry corresponding to the operand geometry (geometry, agent, point) without its holes

Examples:

geometry var0 <- solid(self); 	// var0 equals the geometry corresponding to the geometry of the agent applying the operator without its holes.

`writable`

Possible use:

file writable bool —> file
writable (file , bool) —> file

Result:

Marks the file as read-only or not, depending on the second boolean argument, and returns the first argument

Comment:

A file is created using its native flags. This operator can change them. Beware that this change is system-wide (and not only restrained to GAMA): changing a file to read-only mode (e.g. “writable(f, false)”)

Examples:

file var0 <- shape_file("../images/point_eau.shp") writable false; 	// var0 equals returns a file in read-only mode

`xml_file`

Possible use:

xml_file (string) —> file

Result:

Constructs a file of type xml. Allowed extensions are limited to xml

`years_between`

Possible use:

date years_between date —> int
years_between (date , date) —> int

Result:

Provide the exact number of years between two dates. This number can be positive or negative (if the second operand is smaller than the first one)

Examples:

years_between(d1, d2) -: 10

Operators

Definition

Priority between operators

Using actions as operators

Table of Contents

Operators by categories

3D

Arithmetic operators

BDI

Casting operators

Color-related operators

Comparison operators

Containers-related operators

Date-related operators

Dates

Driving operators

edge

EDP-related operators

Files-related operators

FIPA-related operators

Graphs-related operators

Grid-related operators

Iterator operators

List-related operators

Logical operators

Map comparaison operators

Map-related operators

Material

Matrix-related operators

multicriteria operators

Path-related operators

Points-related operators

Random operators

ReverseOperators

Shape

Spatial operators

Spatial properties operators

Spatial queries operators

Spatial relations operators

Spatial statistical operators

Spatial transformations operators

Species-related operators

Statistical operators

Strings-related operators

System

Time-related operators

Types-related operators

User control operators

Operators

-

Possible use:

Result:

Comment:

Special cases:

Examples:

See also:

:

Possible use:

See also:

::

Possible use:

Result:

Special cases:

!

Possible use:

Result:

Special cases:

Examples:

See also:

!=

Possible use:

Result:

Examples:

See also:

?

Possible use:

Result:

Comment:

Examples:

See also:

`-`

`:`

`::`

`!`

`!=`

`?`

`/`

`.`

`^`

`@`

`*`

`+`

`<`

`<=`

`<>`

`=`

`>`

`>=`

`abs`

`accumulate`

`acos`