#Operators (N to Z)

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).

Table of Contents

Operators by categories

3D

box, cone3D, cube, cylinder, dem, hexagon, pyramid, rgb_to_xyz, set_z, sphere, teapot,

Arithmetic operators

-, /, [^](OperatorsAC#^), [](OperatorsAC#), +, abs, acos, asin, atan, atan2, ceil, cos, cos_rad, div, even, exp, fact, floor, hypot, is_finite, is_number, ln, log, mod, round, signum, sin, sin_rad, sqrt, tan, tan_rad, tanh, with_precision,

BDI

and, eval_when, get_about, get_agent, get_agent_cause, get_decay, get_dominance, get_familiarity, get_intensity, get_lifetime, get_liking, get_praiseworthiness, get_priority, get_solidarity, get_super_intention, new_emotion, new_predicate, new_social_link, or, set_about, set_agent, set_agent_cause, set_decay, set_dominance, set_familiarity, set_intensity, set_liking, set_solidarity, set_truth, with_lifetime, with_praiseworthiness, with_priority, with_values,

Casting operators

as, as_int, as_matrix, font, is, is_skill, list_with, matrix_with, species, to_gaml, topology,

Color-related operators

-, /, [](OperatorsAC#), +, blend, brewer_colors, brewer_palettes, grayscale, hsb, mean, median, rgb, rnd_color, sum,

Comparison operators

!=, <, <=, =, >, >=, between,

Containers-related operators

-, ::, +, accumulate, among, at, collect, contains, contains_all, contains_any, count, distinct, empty, every, first, first_with, get, group_by, in, index_by, inter, interleave, internal_at, internal_integrated_value, last, last_with, length, max, max_of, mean, mean_of, median, min, min_of, mul, one_of, product_of, range, reverse, shuffle, sort_by, sum, sum_of, union, variance_of, where, with_max_of, with_min_of,

Date-related operators

-, !=, +, <, <=, =, >, >=, after, before, between, every, milliseconds_between, minus_days, minus_hours, minus_minutes, minus_months, minus_ms, minus_weeks, minus_years, months_between, plus_days, plus_hours, plus_minutes, plus_months, plus_ms, plus_weeks, plus_years, since, to, until, years_between,

Dates

Driving operators

as_driving_graph,

edge

edge_between,

EDP-related operators

diff, diff2, internal_zero_order_equation,

Files-related operators

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

FIPA-related operators

conversation, message,

Graphs-related operators

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,

Grid-related operators

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,

List-related operators

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,

Map-related operators

as_map, index_of, last_index_of,

Material

material,

Matrix-related operators

-, /, ., [](OperatorsAC#), +, 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,

Path-related operators

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

Points-related operators

-, /, [](OperatorsAC#), +, <, <=, >, >=, 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

-, [](OperatorsAC#), +, 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

-, [](OperatorsAC#), +, 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,

Species-related operators

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,

Strings-related operators

+, <, <=, >, >=, 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,

Time-related operators

date, string,

Types-related operators

User control operators

user_input,

Operators

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

See also:

alpha_index, beta_index, gamma_index, connectivity_index,

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.

See also:

neighbors_of, closest_to, overlapping, agents_overlapping, agents_inside, agent_closest_to, at_distance,

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.

See also:

predecessors_of, successors_of, neighbors_at, closest_to, overlapping, agents_overlapping, agents_inside, agent_closest_to,

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

See also:

folder, file,

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]

See also:

of_species,

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]

See also:

of_generic_species,

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

See also:

contains,

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.

See also:

bool, and, !,

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);

See also:

file,

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

See also:

in_degree_of, degree_of,

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

See also:

in_edges_of,

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

See also:

neighbors_at, neighbors_of, agent_closest_to, agents_inside, closest_to, inside, agents_overlapping,

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

See also:

disjoint_from, crosses, intersects, partially_overlaps, touches,

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

See also:

disjoint_from, crosses, overlaps, intersects, touches,

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

See also:

towards, direction_to, distance_between, direction_between, path_to, distance_to,

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

See also:

towards, direction_to, distance_between, direction_between, path_between, distance_to,

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.

See also:

around, circle, cone, link, norm, point, polygone, rectangle, square, triangle,

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}]

See also:

closest_points_with, farthest_point_to, points_at, points_on,

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

See also:

any_location_in, any_point_in, closest_points_with, farthest_point_to,

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.

See also:

closest_points_with, farthest_point_to, points_at,

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

See also:

binomial, gauss,

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.

See also:

around, circle, cone, line, link, norm, point, polyline, rectangle, square, triangle,

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.

See also:

around, circle, cone, line, link, norm, point, polyline, rectangle, square, triangle,

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}]

See also:

neighbors_of, successors_of,

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

See also:

min_of, max_of, sum_of, mean_of,

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

See also:

weighted_means_DM, electre_DM, evidence_theory_DM,

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.

See also:

around, circle, cone, line, link, norm, point, polygon, polyline, rectangle, square,

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.

See also:

around, circle, cone, line, link, norm, point, polygon, polyline, square, triangle,

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'

See also:

replace_regex,

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'

See also:

replace,

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

See also:

hsb,

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

See also:

flip,

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

See also:

rnd,

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))

See also:

rgb, hsb,

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.

See also:

transformed_by, translated_by,

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

See also:

round, int, with_precision,

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"]

See also:

column_at, columns_list,

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"]]

See also:

columns_list,

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 [](OperatorsAC#)

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)

See also:

reverse,

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]]

See also:

hierarchical_clustering,

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

See also:

cos, tan,

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

See also:

cos, tan,

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

See also:

gauss, truncated_gauss, poisson,

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]

See also:

group_by,

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}

See also:

target_of,

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

See also:

graph,

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.

See also:

around, cone, line, link, norm, point, polygon, polyline, rectangle, square, triangle,

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.

See also:

around, circle, cone, line, link, norm, point, polygon, polyline, rectangle, triangle,

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.

See also:

around, cone, line, link, norm, point, polygon, polyline, super_ellipse, rectangle, square, circle, ellipse, triangle,

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

See also:

mean, mean_deviation,

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 []

See also:

predecessors_of, neighbors_of,

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}

See also:

mul,

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

See also:

min_of, max_of, product_of, mean_of,

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

See also:

cos, sin,

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).

See also:

cos, sin,

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}

See also:

source_of,

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.

See also:

around, cone, line, link, norm, point, polygon, polyline, rectangle, square, triangle,

text_file

Possible use:

• text_file (string) —> file

Result:

Constructs a file of type text. Allowed extensions are limited to txt, data, text

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

See also:

every,

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]

See also:

geometry,

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

See also:

disjoint_from, crosses, overlaps, partially_overlaps, intersects,

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

See also:

distance_between, distance_to, direction_between, path_between, path_to,

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.

See also:

rotated_by, translated_by,

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).

See also:

rotated_by, transformed_by,

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.

See also:

around, circle, cone, line, link, norm, point, polygon, polyline, rectangle, square,

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

See also:

gauss,

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.

See also:

directed,

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

See also:

inter, +,

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'

See also:

lower_case,

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.

See also:

path_between,

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

See also:

mean, median,

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.

See also:

min_of, max_of, sum_of, product_of,

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

See also:

promethee_DM, electre_DM, evidence_theory_DM,

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]

See also:

first_with, last_with, where,

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

See also:

where, with_min_of,

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

See also:

where, with_max_of,

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";

See also:

set_verbose,

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}

See also:

round,

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

See also:

file,

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