# Operators (N to R)

**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, set_z, sphere, teapot,

### Arithmetic operators

-, /, ^, *, +, 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

add_values, and, eval_when, get_about, get_agent, get_agent_cause, get_belief_op, get_belief_with_name_op, get_beliefs_op, get_beliefs_with_name_op, get_current_intention_op, get_decay, get_desire_op, get_desire_with_name_op, get_desires_op, get_desires_with_name_op, get_dominance, get_familiarity, get_ideal_op, get_ideal_with_name_op, get_ideals_op, get_ideals_with_name_op, get_intensity, get_intention_op, get_intention_with_name_op, get_intentions_op, get_intentions_with_name_op, get_lifetime, get_liking, get_modality, get_obligation_op, get_obligation_with_name_op, get_obligations_op, get_obligations_with_name_op, get_plan_name, get_predicate, get_solidarity, get_strength, get_super_intention, get_trust, get_truth, get_uncertainties_op, get_uncertainties_with_name_op, get_uncertainty_op, get_uncertainty_with_name_op, get_values, has_belief_op, has_belief_with_name_op, has_desire_op, has_desire_with_name_op, has_ideal_op, has_ideal_with_name_op, has_intention_op, has_intention_with_name_op, has_obligation_op, has_obligation_with_name_op, has_uncertainty_op, has_uncertainty_with_name_op, new_emotion, new_mental_state, new_predicate, new_social_link, not, or, set_about, set_agent, set_agent_cause, set_decay, set_dominance, set_familiarity, set_intensity, set_lifetime, set_liking, set_modality, set_predicate, set_solidarity, set_strength, set_trust, set_truth, with_values,

### Casting operators

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

### Color-related operators

-, /, *, +, blend, brewer_colors, brewer_palettes, grayscale, hsb, mean, median, rgb, rnd_color, sum,

### Comparison operators

### Containers-related operators

-, ::, +, accumulate, all_match, among, at, collect, contains, contains_all, contains_any, contains_key, 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, none_matches, one_matches, one_of, product_of, range, reverse, shuffle, sort_by, split, split_in, split_using, 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

### Displays

### Driving operators

### edge

### EDP-related operators

### Files-related operators

crs, csv_file, dxf_file, evaluate_sub_model, file, file_exists, folder, gaml_file, geojson_file, get, gif_file, gml_file, grid_file, image_file, is_csv, is_dxf, is_gaml, is_geojson, is_gif, is_gml, is_grid, is_image, is_json, is_obj, is_osm, is_pgm, is_property, is_R, is_saved_simulation, is_shape, is_svg, is_text, is_threeds, is_xml, json_file, new_folder, obj_file, osm_file, pgm_file, property_file, R_file, read, saved_simulation_file, shape_file, step_sub_model, svg_file, text_file, threeds_file, writable, xml_file,

### FIPA-related operators

### GamaMetaType

### 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_circle, layout_force, layout_grid, load_graph_from_file, load_shortest_paths, main_connected_component, max_flow_between, 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, strahler, 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, all_match, as_map, collect, count, create_map, first_with, frequency_of, group_by, index_by, last_with, max_of, mean_of, min_of, none_matches, one_matches, 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

:, !, ?, add_3Dmodel, add_geometry, add_icon, and, or, xor,

### Map comparaison operators

fuzzy_kappa, fuzzy_kappa_sim, kappa, kappa_sim, percent_absolute_deviation,

### Map-related operators

as_map, create_map, index_of, last_index_of,

### Material

### Matrix-related operators

-, /, ., *, +, 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, fuzzy_choquet_DM, promethee_DM, weighted_means_DM,

### Path-related operators

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

### Points-related operators

-, /, *, +, <, <=, >, >=, add_point, angle_between, any_location_in, centroid, closest_points_with, farthest_point_to, grid_at, norm, points_along, points_at, points_on,

### Random operators

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

### ReverseOperators

restore_simulation, restore_simulation_from_file, save_agent, save_simulation, serialize, serialize_agent,

### Shape

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

### Spatial operators

-, *, +, add_point, agent_closest_to, agent_farthest_to, agents_at_distance, agents_inside, agents_overlapping, angle_between, any_location_in, arc, around, as_4_grid, as_grid, as_hexagonal_grid, at_distance, at_location, box, centroid, circle, clean, clean_network, 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, inverse_rotation, line, link, masked_by, moran, neighbors_at, neighbors_of, normalized_rotation, overlapping, overlaps, partially_overlaps, path_between, path_to, plan, points_along, points_at, points_on, polygon, polyhedron, pyramid, rectangle, rotated_by, rotation_composition, 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_segments, to_squares, to_sub_geometries, touches, towards, transformed_by, translated_by, triangle, triangulate, union, using, voronoi, with_precision, without_holes,

### Spatial properties operators

covers, crosses, intersects, partially_overlaps, touches,

### Spatial queries operators

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

### Spatial relations operators

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

### Spatial statistical operators

hierarchical_clustering, simple_clustering_by_distance,

### Spatial transformations operators

-, *, +, as_4_grid, as_grid, as_hexagonal_grid, at_location, clean, clean_network, convex_hull, CRS_transform, inverse_rotation, normalized_rotation, rotated_by, rotation_composition, scaled_to, simplification, skeletonize, smooth, split_geometry, split_lines, to_GAMA_CRS, to_rectangles, to_segments, to_squares, to_sub_geometries, transformed_by, translated_by, triangulate, voronoi, with_precision, without_holes,

### Species-related operators

index_of, last_index_of, of_generic_species, of_species,

### Statistical operators

auto_correlation, beta, binomial_coeff, binomial_complemented, binomial_sum, build, chi_square, chi_square_complemented, corR, correlation, covariance, dbscan, distribution_of, distribution2d_of, dtw, durbin_watson, frequency_of, gamma, gamma_distribution, gamma_distribution_complemented, gamma_rnd, geometric_mean, gini, harmonic_mean, hierarchical_clustering, incomplete_beta, incomplete_gamma, incomplete_gamma_complement, kmeans, kurtosis, kurtosis, log_gamma, max, mean, mean_deviation, meanR, median, min, moment, moran, mul, normal_area, normal_density, normal_inverse, predict, pValue_for_fStat, pValue_for_tStat, quantile, quantile_inverse, rank_interpolated, rms, simple_clustering_by_distance, skew, skewness, split, split_in, split_using, standard_deviation, student_area, student_t_inverse, sum, variance, 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,

### SubModel

### System

., command, copy, copy_to_clipboard, dead, eval_gaml, every, is_error, is_warning, user_input,

### Time-related operators

### Types-related operators

action, agent, attributes, BDIPlan, bool, container, emotion, file, float, gaml_type, geometry, graph, int, kml, list, map, material, matrix, mental_state, Norm, pair, path, point, predicate, regression, rgb, Sanction, skill, social_link, topology, unknown,

### User control operators

## 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`

--->`list`

(`neighbors_at`

`geometry`

,`float`

) --->`list`

#### 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:

```
list 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`

--->`list`

(`neighbors_of`

`graph`

,`unknown`

) --->`list`

`topology`

`neighbors_of`

`agent`

--->`list`

(`neighbors_of`

`topology`

,`agent`

) --->`list`

(`neighbors_of`

`topology`

,`geometry`

,`float`

) --->`list`

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

```
list var0 <- neighbors_of (topology(self), self,10); // var0 equals all the agents located at a distance lower or equal to 10 to the agent applying the operator considering its topology.
```

#### Examples:

```
list var1 <- graphEpidemio neighbors_of (node(3)); // var1 equals [node0,node2]
list var2 <- graphFromMap neighbors_of node({12,45}); // var2 equals [{1.0,5.0},{34.0,56.0}]
list var3 <- topology(self) neighbors_of self; // var3 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`

`predicate`

--->`emotion`

(`new_emotion`

`string`

,`predicate`

) --->`emotion`

`string`

`new_emotion`

`agent`

--->`emotion`

(`new_emotion`

`string`

,`agent`

) --->`emotion`

`string`

`new_emotion`

`float`

--->`emotion`

(`new_emotion`

`string`

,`float`

) --->`emotion`

(`new_emotion`

`string`

,`float`

,`float`

) --->`emotion`

(`new_emotion`

`string`

,`float`

,`agent`

) --->`emotion`

(`new_emotion`

`string`

,`float`

,`predicate`

) --->`emotion`

(`new_emotion`

`string`

,`predicate`

,`agent`

) --->`emotion`

(`new_emotion`

`string`

,`float`

,`predicate`

,`float`

) --->`emotion`

(`new_emotion`

`string`

,`float`

,`float`

,`agent`

) --->`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,intensity,decay) 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,about) 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) 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)

#### Examples:

```
emotion("joy",12.3,4.0)
emotion("joy",12.3,eatFood,4)
emotion("joy",12.3,eatFood,4)
emotion("joy",12.3,eatFood,4)
emotion("joy",12.3,eatFood,4)
emotion("joy",eatFood)
emotion("joy")
emotion("joy",12.3,eatFood)
emotion("joy",12.3,eatFood,4)
emotion("joy",12.3,eatFood,4)
emotion("joy",12.3)
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:

`new_mental_state`

#### Possible use:

(`new_mental_state`

`string`

) --->`mental_state`

`string`

`new_mental_state`

`predicate`

--->`mental_state`

(`new_mental_state`

`string`

,`predicate`

) --->`mental_state`

`string`

`new_mental_state`

`emotion`

--->`mental_state`

(`new_mental_state`

`string`

,`emotion`

) --->`mental_state`

`string`

`new_mental_state`

`mental_state`

--->`mental_state`

(`new_mental_state`

`string`

,`mental_state`

) --->`mental_state`

(`new_mental_state`

`string`

,`emotion`

,`int`

) --->`mental_state`

(`new_mental_state`

`string`

,`mental_state`

,`int`

) --->`mental_state`

(`new_mental_state`

`string`

,`predicate`

,`float`

) --->`mental_state`

(`new_mental_state`

`string`

,`predicate`

,`int`

) --->`mental_state`

(`new_mental_state`

`string`

,`mental_state`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`mental_state`

,`float`

) --->`mental_state`

(`new_mental_state`

`string`

,`predicate`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`emotion`

,`float`

) --->`mental_state`

(`new_mental_state`

`string`

,`emotion`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`mental_state`

,`float`

,`int`

) --->`mental_state`

(`new_mental_state`

`string`

,`predicate`

,`float`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`emotion`

,`float`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`predicate`

,`int`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`emotion`

,`int`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`emotion`

,`float`

,`int`

) --->`mental_state`

(`new_mental_state`

`string`

,`predicate`

,`float`

,`int`

) --->`mental_state`

(`new_mental_state`

`string`

,`mental_state`

,`int`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`mental_state`

,`float`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`emotion`

,`float`

,`int`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`mental_state`

,`float`

,`int`

,`agent`

) --->`mental_state`

(`new_mental_state`

`string`

,`predicate`

,`float`

,`int`

,`agent`

) --->`mental_state`

#### Result:

a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state a new mental state

#### Examples:

```
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
new_mental-state(belief)
```

`new_predicate`

#### Possible use:

(`new_predicate`

`string`

) --->`predicate`

`string`

`new_predicate`

`bool`

--->`predicate`

(`new_predicate`

`string`

,`bool`

) --->`predicate`

`string`

`new_predicate`

`agent`

--->`predicate`

(`new_predicate`

`string`

,`agent`

) --->`predicate`

`string`

`new_predicate`

`map`

--->`predicate`

(`new_predicate`

`string`

,`map`

) --->`predicate`

(`new_predicate`

`string`

,`map`

,`bool`

) --->`predicate`

(`new_predicate`

`string`

,`map`

,`agent`

) --->`predicate`

(`new_predicate`

`string`

,`map`

,`bool`

,`agent`

) --->`predicate`

#### Result:

a new predicate with the given is_true (name, is_true) a new predicate with the given properties (name, values, is_true) a new predicate with the given properties (name, values, 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) a new predicate with the given properties (name, values)

#### Examples:

```
predicate("hasWater", true)
predicate("people to meet", ["time"::10], true)
predicate("people to meet", ["time"::10], agentA)
predicate("people to meet", ["time"::10], true, agentA)
predicate("people to meet", ["time"::10], true)
predicate("people to meet")
predicate("people to meet", people1 )
```

`new_social_link`

#### Possible use:

(`new_social_link`

`agent`

) --->`social_link`

(`new_social_link`

`agent`

,`float`

,`float`

,`float`

,`float`

) --->`social_link`

#### Result:

a new social link a new social link

#### Examples:

```
new_social_link(agentA,0.0,-0.1,0.2,0.1)
new_social_link(agentA)
```

`node`

#### Possible use:

(`node`

`unknown`

) --->`unknown`

`unknown`

`node`

`float`

--->`unknown`

(`node`

`unknown`

,`float`

) --->`unknown`

`nodes`

#### Possible use:

(`nodes`

`container`

) --->`container`

`none_matches`

#### Possible use:

`container`

`none_matches`

`any expression`

--->`bool`

(`none_matches`

`container`

,`any expression`

) --->`bool`

#### Result:

Returns true if none of the elements of the left-hand operand make the right-hand operand evaluate to true. Returns true if the left-hand operand is empty. 'c none_matches each.property' is strictly equivalent to '(c count each.property) = 0'

#### Comment:

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

#### Special cases:

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

#### Examples:

```
bool var0 <- [1,2,3,4,5,6,7,8] none_matches (each > 3); // var0 equals false
bool var1 <- [1::2, 3::4, 5::6] none_matches (each > 4); // var1 equals false
```

#### See also:

one_matches, all_match, count,

`none_verifies`

Same signification as none_matches

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

`Norm`

#### Possible use:

(`Norm`

`any`

) --->`Norm`

#### Result:

`normal_area`

#### Possible use:

(`normal_area`

`float`

,`float`

,`float`

) --->`float`

#### Result:

Returns the area to the left of x in the normal distribution with the given mean and standard deviation.

#### Examples:

```
float var0 <- normal_area(0.9,0,1) with_precision(3); // var0 equals 0.816
```

`normal_density`

#### Possible use:

(`normal_density`

`float`

,`float`

,`float`

) --->`float`

#### Result:

Returns the probability of x in the normal distribution with the given mean and standard deviation.

#### Examples:

```
float var0 <- (normal_density(2,1,1)*100) with_precision 2; // var0 equals 24.2
```

`normal_inverse`

#### Possible use:

(`normal_inverse`

`float`

,`float`

,`float`

) --->`float`

#### Result:

Returns the x in the normal distribution with the given mean and standard deviation, to the left of which lies the given area. normal.Inverse returns the value in terms of standard deviations from the mean, so we need to adjust it for the given mean and standard deviation.

#### Examples:

```
float var0 <- normal_inverse(0.98,0,1) with_precision(2); // var0 equals 2.05
```

`normalized_rotation`

#### Possible use:

(`normalized_rotation`

`pair`

) --->`pair<float,point>`

#### Result:

The rotation normalized according to Euler formalism with a positive angle, such that each rotation has a unique set of parameters (positive angle, normalize axis rotation).

#### Examples:

```
pair<float,point> var0 <- normalized_rotation(-38.0::{1,1,1}); // var0 equals 38.0::{-0.5773502691896258,-0.5773502691896258,-0.5773502691896258}
```

#### See also:

[rotation_composition, inverse_rotation](OperatorsSZ#rotation_composition, inverse_rotation),

`not`

Same signification as !

`not`

#### Possible use:

(`not`

`predicate`

) --->`predicate`

#### Result:

create a new predicate with the inverse truth value

#### Examples:

```
not predicate1
```

`obj_file`

#### Possible use:

(`obj_file`

`string`

) --->`file`

`string`

`obj_file`

`pair<float,point>`

--->`file`

(`obj_file`

`string`

,`pair<float,point>`

) --->`file`

`string`

`obj_file`

`string`

--->`file`

(`obj_file`

`string`

,`string`

) --->`file`

(`obj_file`

`string`

,`string`

,`pair<float,point>`

) --->`file`

#### Result:

Constructs a file of type obj. Allowed extensions are limited to obj, OBJ

#### Special cases:

- obj_file(string): This file constructor allows to read an obj file. The associated mlt file have to have the same name as the file to be read.

```
file f <- obj_file("file.obj");
```

- obj_file(string,pair<float,point>): This file constructor allows to read an obj file and apply an init rotation to it. The rotationis a pair angle::rotation vector. The associated mlt file have to have the same name as the file to be read.

```
file f <- obj_file("file.obj", 90.0::{-1,0,0});
```

- obj_file(string,string): This file constructor allows to read an obj file, using a specific mlt file

```
file f <- obj_file("file.obj","file.mlt");
```

- obj_file(string,string,pair<float,point>): This file constructor allows to read an obj file, using a specific mlt file, and apply an init rotation to it. The rotationis a pair angle::rotation vector

```
file f <- obj_file("file.obj","file.mlt", 90.0::{-1,0,0});
```

#### See also:

`of`

Same signification as .

`of_generic_species`

#### Possible use:

`container`

`of_generic_species`

`species`

--->`list`

(`of_generic_species`

`container`

,`species`

) --->`list`

#### 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 speciesA {}
// species sub_speciesA parent: speciesA {}
list var2 <- [sub_speciesA(0),sub_speciesA(1),speciesA(2),speciesA(3)] of_generic_species speciesA; // var2 equals [sub_speciesA0,sub_speciesA1,speciesA0,speciesA1]
list var3 <- [sub_speciesA(0),sub_speciesA(1),speciesA(2),speciesA(3)] of_generic_species sous_test; // var3 equals [sub_speciesA0,sub_speciesA1]
list var4 <- [sub_speciesA(0),sub_speciesA(1),speciesA(2),speciesA(3)] of_species speciesA; // var4 equals [speciesA0,speciesA1]
list var5 <- [sub_speciesA(0),sub_speciesA(1),speciesA(2),speciesA(3)] of_species sous_test; // var5 equals [sub_speciesA0,sub_speciesA1]
```

#### See also:

`of_species`

#### Possible use:

`container`

`of_species`

`species`

--->`list`

(`of_species`

`container`

,`species`

) --->`list`

#### 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:

```
list var0 <- (self neighbors_at 10) of_species (species (self)); // var0 equals all the neighboring agents of the same species.
list var1 <- [test(0),test(1),node(1),node(2)] of_species test; // var1 equals [test0,test1]
```

#### See also:

`one_matches`

#### Possible use:

`container`

`one_matches`

`any expression`

--->`bool`

(`one_matches`

`container`

,`any expression`

) --->`bool`

#### Result:

Returns true if at least one of the elements of the left-hand operand make the right-hand operand evaluate to true. Returns false if the left-hand operand is empty. 'c one_matches each.property' is strictly equivalent to '(c count each.property) > 0' but faster in most cases (as it is a shortcircuited operator)

#### Comment:

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

#### Special cases:

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

#### Examples:

```
bool var0 <- [1,2,3,4,5,6,7,8] one_matches (each > 3); // var0 equals true
bool var1 <- [1::2, 3::4, 5::6] one_matches (each > 4); // var1 equals true
```

#### See also:

none_matches, all_match, count,

`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:

`one_verifies`

Same signification as one_matches

`open_simplex_generator`

#### Possible use:

(`open_simplex_generator`

`float`

,`float`

,`float`

) --->`float`

#### Result:

take a x, y and a bias parameters and gives a value

#### Examples:

```
float var0 <- open_simplex_generator(2,3,253); // var0 equals 10.2
```

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

#### Examples:

```
bool var0 <- true or false; // var0 equals true
bool var1 <- false or false; // var1 equals false
bool var2 <- false or true; // var2 equals true
bool var3 <- true or true; // var3 equals true
int a <-3 ; int b <- 4; int c <- 7;
bool var5 <- ((a+b) = c ) or ((a+b) > c ); // var5 equals true
```

#### See also:

`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:

(`osm_file`

`string`

) --->`file`

`string`

`osm_file`

`map<string,list>`

--->`file`

(`osm_file`

`string`

,`map<string,list>`

) --->`file`

#### Result:

Constructs a file of type osm. Allowed extensions are limited to osm, pbf, bz2, gz

#### Special cases:

- osm_file(string): This file constructor allows to read a osm (.osm, .pbf, .bz2, .gz) file (using WGS84 coordinate system for the data)

```
file f <- osm_file("file");
```

- osm_file(string,map<string,list>): This file constructor allows to read an osm (.osm, .pbf, .bz2, .gz) file (using WGS84 coordinate system for the data)The map is used to filter the objects in the file according their attributes: for each key (string) of the map, only the objects that have a value for the attribute contained in the value set are kept. For an exhaustive list of the attibute of OSM data, see: http://wiki.openstreetmap.org/wiki/Map_Features

```
void var1 <- file f <- osm_file("file", map(["highway"::["primary", "secondary"], "building"::["yes"], "amenity"::[]]));; // var1 equals f will contain all the objects of file that have the attibute 'highway' with the value 'primary' or 'secondary', and the objects that have the attribute 'building' with the value 'yes', and all the objects that have the attribute 'aminity' (whatever the value).
```

#### See also:

`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:

`out_edges_of`

#### Possible use:

`graph`

`out_edges_of`

`unknown`

--->`list`

(`out_edges_of`

`graph`

,`unknown`

) --->`list`

#### Result:

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

#### Examples:

```
list var1 <- graphFromMap out_edges_of (node(3)); // var1 equals 3
```

#### See also:

`overlapping`

#### Possible use:

`container<unknown,geometry>`

`overlapping`

`geometry`

--->`list<geometry>`

(`overlapping`

`container<unknown,geometry>`

,`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`

`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:

#### Special cases:

- if the operand is a path, returns this path
- if the operand is a geometry of an agent, returns a path from the list of points of the geometry
- if the operand is a list, cast each element of the list as a point and create a path from these points

```
path p <- path([{12,12},{30,30},{50,50}]);
```

`path_between`

#### Possible use:

`list<agent>`

`path_between`

`container<unknown,geometry>`

--->`path`

(`path_between`

`list<agent>`

,`container<unknown,geometry>`

) --->`path`

`map<agent,unknown>`

`path_between`

`container<unknown,geometry>`

--->`path`

(`path_between`

`map<agent,unknown>`

,`container<unknown,geometry>`

) --->`path`

`topology`

`path_between`

`container<unknown,geometry>`

--->`path`

(`path_between`

`topology`

,`container<unknown,geometry>`

) --->`path`

(`path_between`

`map<agent,unknown>`

,`geometry`

,`geometry`

) --->`path`

(`path_between`

`graph`

,`geometry`

,`geometry`

) --->`path`

(`path_between`

`topology`

,`geometry`

,`geometry`

) --->`path`

(`path_between`

`list<agent>`

,`geometry`

,`geometry`

) --->`path`

#### Result:

The shortest path between two objects according to set of cells with corresponding weights The shortest path between a list of two objects in a graph The shortest path between several objects according to set of cells The shortest path between several objects according to set of cells with corresponding weights The shortest path between two objects according to set of cells

#### Examples:

```
path var0 <- path_between (cell_grid as_map (each::each.is_obstacle ? 9999.0 : 1.0), ag1, ag2); // var0 equals A path between ag1 and ag2 passing through the given cell_grid agents with a minimal cost
path var1 <- path_between (my_graph, ag1, ag2); // var1 equals A path between ag1 and ag2
path var2 <- path_between (cell_grid where each.is_free, [ag1, ag2, ag3]); // var2 equals A path between ag1 and ag2 and ag3 passing through the given cell_grid agents
path var3 <- path_between (cell_grid as_map (each::each.is_obstacle ? 9999.0 : 1.0), [ag1, ag2, ag3]); // var3 equals A path between ag1 and ag2 and ag3 passing through the given cell_grid agents with minimal cost
path var4 <- my_topology path_between (ag1, ag2); // var4 equals A path between ag1 and ag2
path var5 <- path_between (cell_grid where each.is_free, ag1, ag2); // var5 equals A path between ag1 and ag2 passing through the given cell_grid agents
path var6 <- my_topology path_between [ag1, ag2]; // var6 equals A path between ag1 and ag2
```

#### 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
```

`pbinom`

Same signification as binomial_sum

`pchisq`

Same signification as chi_square

`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:

```
float var0 <- percent_absolute_deviation([200,300,150,150,200],[250,250,100,200,200]); // var0 equals 20.0
```

`percentile`

Same signification as quantile_inverse

`pgamma`

Same signification as gamma_distribution

`pgm_file`

#### Possible use:

(`pgm_file`

`string`

) --->`file`

#### Result:

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

#### Special cases:

- pgm_file(string): This file constructor allows to read a pgm file

```
file f <-pgm_file("file.pgm");
```

#### See also:

`plan`

#### Possible use:

`container<unknown,geometry>`

`plan`

`float`

--->`geometry`

(`plan`

`container<unknown,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:

```
date var0 <- date('2000-01-01') plus_days 12; // var0 equals date('2000-01-13')
```

`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:

```
// equivalent to date1 + 15 #h
date var1 <- date('2000-01-01') plus_hours 24; // var1 equals date('2000-01-02')
```

`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:

```
// equivalent to date1 + 5 #mn
date var1 <- date('2000-01-01') plus_minutes 5 ; // var1 equals date('2000-01-01 00:05:00')
```

`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:

```
date var0 <- date('2000-01-01') plus_months 5; // var0 equals date('2000-06-01')
```

`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:

```
// equivalent to date('2000-01-01') + 15 #ms
date var1 <- date('2000-01-01') plus_ms 1000 ; // var1 equals date('2000-01-01 00:00:01')
```

`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:

```
date var0 <- date('2000-01-01') plus_weeks 15; // var0 equals date('2000-04-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:

```
date var0 <- date('2000-01-01') plus_years 15; // var0 equals date('2015-01-01')
```

`pnorm`

Same signification as normal_area

`point`

#### Possible use:

(`point`

`any`

) --->`point`

`points_along`

#### Possible use:

`geometry`

`points_along`

`list<float>`

--->`list`

(`points_along`

`geometry`

,`list<float>`

) --->`list`

#### 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:

```
list 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`

--->`list`

(`points_on`

`geometry`

,`float`

) --->`list`

#### Result:

A list of points of the operand-geometry distant from each other to the float right-operand .

#### Examples:

```
list 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:

`polygon`

#### Possible use:

(`polygon`

`container<unknown,geometry>`

) --->`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.
float var1 <- polygon([{0,0}, {0,10}, {10,10}, {10,0}]).area; // var1 equals 100.0
point var2 <- polygon([{0,0}, {0,10}, {10,10}, {10,0}]).location; // var2 equals point(5.0,5.0,0.0)
```

#### See also:

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

`polyhedron`

#### Possible use:

`container<unknown,geometry>`

`polyhedron`

`float`

--->`geometry`

(`polyhedron`

`container<unknown,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`

--->`list`

(`predecessors_of`

`graph`

,`unknown`

) --->`list`

#### 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:

```
list var1 <- graphEpidemio predecessors_of ({1,5}); // var1 equals []
list var2 <- graphEpidemio predecessors_of node({34,56}); // var2 equals [{12;45}]
```

#### See also:

`predicate`

#### Possible use:

(`predicate`

`any`

) --->`predicate`

#### Result:

`predict`

#### Possible use:

`regression`

`predict`

`list`

--->`float`

(`predict`

`regression`

,`list`

) --->`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 var1 <- [1::2, 3::4, 5::6] product_of (each); // var1 equals 48
```

#### Examples:

```
unknown var0 <- [1,2] product_of (each * 10 ); // var0 equals 200
```

#### See also:

min_of, max_of, sum_of, mean_of,

`promethee_DM`

#### Possible use:

`list<list>`

`promethee_DM`

`list<map<string,unknown>>`

--->`int`

(`promethee_DM`

`list<list>`

,`list<map<string,unknown>>`

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

`string`

`property_file`

`map<string,string>`

--->`file`

(`property_file`

`string`

,`map<string,string>`

) --->`file`

#### Result:

Constructs a file of type property. Allowed extensions are limited to properties

#### Special cases:

- property_file(string): This file constructor allows to read a property file (.properties)

```
file f <-property_file("file.properties");
```

- property_file(string,map<string,string>): This file constructor allows to store a map in a property file (it does not save it - just store it in memory)

```
file f <-property_file("file.properties", map(["param1"::1.0,"param3"::10.0 ]));
```

#### See also:

`pValue_for_fStat`

#### Possible use:

(`pValue_for_fStat`

`float`

,`int`

,`int`

) --->`float`

#### Result:

Returns the P value of F statistic fstat with numerator degrees of freedom dfn and denominator degress of freedom dfd. Uses the incomplete Beta function.

#### Examples:

```
float var0 <- pValue_for_fStat(1.9,10,12) with_precision(3); // var0 equals 0.145
```

`pValue_for_tStat`

#### Possible use:

`float`

`pValue_for_tStat`

`int`

--->`float`

(`pValue_for_tStat`

`float`

,`int`

) --->`float`

#### Result:

Returns the P value of the T statistic tstat with df degrees of freedom. This is a two-tailed test so we just double the right tail which is given by studentT of -|tstat|.

#### Examples:

```
float var0 <- pValue_for_tStat(0.9,10) with_precision(3); // var0 equals 0.389
```

`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,

`quantile`

#### Possible use:

`container`

`quantile`

`float`

--->`float`

(`quantile`

`container`

,`float`

) --->`float`

#### Result:

Returns the phi-quantile; that is, an element elem for which holds that phi percent of data elements are less than elem. The quantile need not necessarily be contained in the data sequence, it can be a linear interpolation. Note that the container holding the values must be sorted first

#### Examples:

```
float var0 <- quantile([1,3,5,6,9,11,12,13,19,21,22,32,35,36,45,44,55,68,79,80,81,88,90,91,92,100], 0.5); // var0 equals 35.5
```

`quantile_inverse`

#### Possible use:

`container`

`quantile_inverse`

`float`

--->`float`

(`quantile_inverse`

`container`

,`float`

) --->`float`

#### Result:

Returns how many percent of the elements contained in the receiver are <= element. Does linear interpolation if the element is not contained but lies in between two contained elements. Note that the container holding the values must be sorted first

#### Examples:

```
float var0 <- quantile_inverse([1,3,5,6,9,11,12,13,19,21,22,32,35,36,45,44,55,68,79,80,81,88,90,91,92,100], 35.5) with_precision(2); // var0 equals 0.52
```

`R_correlation`

Same signification as corR

`R_file`

#### Possible use:

(`R_file`

`string`

) --->`file`

`string`

`R_file`

`map`

--->`file`

(`R_file`

`string`

,`map`

) --->`file`

#### Result:

Constructs a file of type R. Allowed extensions are limited to r

#### Special cases:

- R_file(string): This file constructor allows to read a R file

```
file f <-R_file("file.r");
```

- R_file(string,map): This file constructor allows to store a map in a R file (it does not save it - just store it in memory)

```
file f <-R_file("file.r",map(["param1"::1.0,"param2"::10.0 ]));
```

#### See also:

is_R,

`R_mean`

Same signification as meanR

`range`

#### Possible use:

(`range`

`int`

) --->`list`

`int`

`range`

`int`

--->`list`

(`range`

`int`

,`int`

) --->`list`

(`range`

`int`

,`int`

,`int`

) --->`list`

#### Result:

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

#### Examples:

```
list var0 <- range(0,2); // var0 equals [0,1,2]
```

`rank_interpolated`

#### Possible use:

`container`

`rank_interpolated`

`float`

--->`float`

(`rank_interpolated`

`container`

,`float`

) --->`float`

#### Result:

Returns the linearly interpolated number of elements in a list less or equal to a given element. The rank is the number of elements <= element. Ranks are of the form {0, 1, 2,..., sortedList.size()}. If no element is <= element, then the rank is zero. If the element lies in between two contained elements, then linear interpolation is used and a non integer value is returned. Note that the container holding the values must be sorted first

#### Examples:

```
float var0 <- rank_interpolated([1,3,5,6,9,11,12,13,19,21,22,32,35,36,45,44,55,68,79,80,81,88,90,91,92,100], 35); // var0 equals 13.0
```

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

`point`

`rectangle`

`point`

--->`geometry`

(`rectangle`

`point`

,`point`

) --->`geometry`

`float`

`rectangle`

`float`

--->`geometry`

(`rectangle`

`float`

,`float`

) --->`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.
float var1 <- rectangle({10, 5}).area; // var1 equals 50.0
geometry var2 <- rectangle({0.0,0.0}, {10.0,10.0}); // var2 equals a geometry as a rectangle with {1.0,1.0} as the upper-left corner, {10.0,10.0} as the lower-right corner.
float var3 <- rectangle({0.0,0.0}, {10.0,10.0}).area; // var3 equals 100.0
geometry var4 <- rectangle(10, 5); // var4 equals a geometry as a rectangle with width = 10 and height = 5.
float var5 <- rectangle(10, 5).area; // var5 equals 50.0
```

#### See also:

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

`reduced_by`

Same signification as -

`regression`

#### Possible use:

(`regression`

`any`

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

WARNING / side effect: this operator modifies the operand and does not create a new graph. 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`

#### 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:

`restore_simulation`

#### Possible use:

(`restore_simulation`

`string`

) --->`int`

#### Result:

restore_simulation

`restore_simulation_from_file`

#### Possible use:

(`restore_simulation_from_file`

`ummisco.gama.serializer.gaml.GamaSavedSimulationFile`

) --->`int`

#### Result:

restoreSimulationFromFile

`reverse`

#### Possible use:

(`reverse`

`map<K,V>`

) --->`map`

(`reverse`

`container<KeyType,ValueType>`

) --->`container<unknown,unknown>`

(`reverse`

`string`

) --->`string`

#### 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 list, reverse returns a copy of the operand list with elements in the reversed order

```
list<int> var2 <- reverse ([10,12,14]); // var2 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)

```
map<int,string> var3 <- reverse (['k1'::44, 'k2'::32, 'k3'::12]); // var3 equals [44::'k1', 32::'k2', 12::'k3']
```

- if it is a matrix, reverse returns a new matrix containing the transpose of the operand.

```
matrix<string> var4 <- reverse(matrix([["c11","c12","c13"],["c21","c22","c23"]])); // var4 equals matrix([["c11","c21"],["c12","c22"],["c13","c23"]])
```

- if it is a string, reverse returns a new string with characters in the reversed order

```
string var5 <- reverse ('abcd'); // var5 equals 'dcba'
```

#### Examples:

```
map<int,int> m <- [1::111,2::222, 3::333, 4::444];
map var1 <- reverse(m); // var1 equals map([111::1,222::2,333::3,444::4])
```

`rewire_n`

#### Possible use:

`graph`

`rewire_n`

`int`

--->`graph`

(`rewire_n`

`graph`

,`int`

) --->`graph`

#### Result:

rewires the given count of edges.

#### Comment:

WARNING / side effect: this operator modifies the operand and does not create a new graph. 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`

,`int`

) --->`rgb`

(`rgb`

`int`

,`int`

,`int`

,`float`

) --->`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 and 255)
- 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 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
- It can be used with r=red, g=green, b=blue (each between 0 and 255), a=alpha (between 0.0 and 1.0)

#### Examples:

```
rgb var0 <- rgb (255,0,0,125); // var0 equals a light red color
rgb var2 <- rgb(rgb(255,0,0),0.5); // var2 equals a light red color
rgb var3 <- rgb(rgb(255,0,0),125); // var3 equals a light red color
rgb var4 <- rgb ("red"); // var4 equals rgb(255,0,0)
rgb var5 <- rgb (255,0,0); // var5 equals #red
rgb var6 <- rgb (255,0,0,0.5); // var6 equals a light red color
```

#### See also:

hsb,

`rgb`

#### Possible use:

(`rgb`

`any`

) --->`rgb`

`rms`

#### Possible use:

`int`

`rms`

`float`

--->`float`

(`rms`

`int`

,`float`

) --->`float`

#### Result:

Returns the RMS (Root-Mean-Square) of a data sequence. The RMS of data sequence is the square-root of the mean of the squares of the elements in the data sequence. It is a measure of the average size of the elements of a data sequence.

#### Examples:

```
list<float> data_sequence <- [6.0, 7.0, 8.0, 9.0];
list<float> squares <- data_sequence collect (each*each);
float var2 <- rms(length(data_sequence),sum(squares)) with_precision(4) ; // var2 equals 7.5829
```

`rnd`

#### Possible use:

(`rnd`

`int`

) --->`int`

(`rnd`

`float`

) --->`float`

(`rnd`

`point`

) --->`point`

`int`

`rnd`

`int`

--->`int`

(`rnd`

`int`

,`int`

) --->`int`

`float`

`rnd`

`float`

--->`float`

(`rnd`

`float`

,`float`

) --->`float`

`point`

`rnd`

`point`

--->`point`

(`rnd`

`point`

,`point`

) --->`point`

(`rnd`

`int`

,`int`

,`int`

) --->`int`

(`rnd`

`point`

,`point`

,`float`

) --->`point`

(`rnd`

`float`

,`float`

,`float`

) --->`float`

#### 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:

```
int var0 <- rnd (2, 12, 4); // var0 equals 2, 6 or 10
int var1 <- rnd (2); // var1 equals 0, 1 or 2
float var2 <- rnd (1000) / 1000; // var2 equals a float between 0 and 1 with a precision of 0.001
int var3 <- rnd (2, 4); // var3 equals 2, 3 or 4
float var4 <- rnd(3.4); // var4 equals a random float between 0.0 and 3.4
point var5 <- rnd ({2.0, 4.0}, {2.0, 5.0, 10.0}, 1); // var5 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 var6 <- rnd ({2.5,3, 0.0}); // var6 equals {x,y} with x in [0.0,2.0], y in [0.0,3.0], z = 0.0
float var7 <- rnd (2.0, 4.0); // var7 equals a float number between 2.0 and 4.0
point var8 <- rnd ({2.0, 4.0}, {2.0, 5.0, 10.0}); // var8 equals a point with x = 2.0, y between 2.0 and 4.0 and z between 0.0 and 10.0
float var9 <- rnd (2.0, 4.0, 0.5); // var9 equals a float number between 2.0 and 4.0 every 0.5
```

#### See also:

flip,

`rnd_choice`

#### Possible use:

(`rnd_choice`

`list`

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

`int`

`rnd_color`

`int`

--->`rgb`

(`rnd_color`

`int`

,`int`

) --->`rgb`

#### Result:

Return a random color equivalent to rgb(rnd(first_op, last_op),rnd(first_op, last_op),rnd(first_op, last_op)) rgb color

#### Comment:

Return a random color equivalent to rgb(rnd(operand),rnd(operand),rnd(operand))

#### Examples:

```
rgb var0 <- rnd_color(100, 200); // var0 equals a random color, equivalent to rgb(rnd(100, 200),rnd(100, 200),rnd(100, 200))
rgb var1 <- rnd_color(255); // var1 equals a random color, equivalent to rgb(rnd(255),rnd(255),rnd(255))
```

#### See also:

`rotated_by`

#### Possible use:

`geometry`

`rotated_by`

`int`

--->`geometry`

(`rotated_by`

`geometry`

,`int`

) --->`geometry`

`point`

`rotated_by`

`pair`

--->`point`

(`rotated_by`

`point`

,`pair`

) --->`point`

`geometry`

`rotated_by`

`pair`

--->`geometry`

(`rotated_by`

`geometry`

,`pair`

) --->`geometry`

`geometry`

`rotated_by`

`float`

--->`geometry`

(`rotated_by`

`geometry`

,`float`

) --->`geometry`

(`rotated_by`

`geometry`

,`float`

,`point`

) --->`geometry`

#### Result:

A geometry resulting from the application of the right-hand rotation operand (angles in degree) to the left-hand operand (geometry, agent, point) 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 operand angles (degree) along the operand axis to the left-hand operand (geometry, agent, point)

#### Comment:

the right-hand operand can be a float or a intreturn a vector that results from

#### Examples:

```
geometry var0 <- rotated_by(pyramid(10),45.0::{1,0,0}); // var0 equals the geometry resulting from a 45 degrees rotation along the {1,0,0} vector to the geometry of the agent applying the operator.
geometry var1 <- self rotated_by 45; // var1 equals the geometry resulting from a 45 degrees rotation to the geometry of the agent applying the operator.
geometry var2 <- rotated_by(pyramid(10),45.0, {1,0,0}); // var2 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,

`rotation_composition`

#### Possible use:

(`rotation_composition`

`list<pair>`

) --->`pair<float,point>`

#### Result:

The rotation resulting from the composition of the rotations in the list, from left to right. Angles are in degrees.

#### Examples:

```
pair<float,point> var0 <- rotation_composition([38.0::{1,1,1},90.0::{1,0,0}]); // var0 equals 115.22128507898108::{0.9491582126366207,0.31479943993669307,-0.0}
```

#### See also:

`round`

#### Possible use:

(`round`

`int`

) --->`int`

(`round`

`float`

) --->`int`

(`round`

`point`

) --->`point`

#### Result:

Returns the rounded value of the operand.

#### Special cases:

- if the operand is an int, round returns it

#### Examples:

```
int var0 <- round (0.51); // var0 equals 1
int var1 <- round (100.2); // var1 equals 100
int var2 <- round(-0.51); // var2 equals -1
point var3 <- {12345.78943, 12345.78943, 12345.78943} with_precision 2; // var3 equals {12345.79,12345.79,12345.79}
```

#### See also:

`row_at`

#### Possible use:

`matrix<unknown>`

`row_at`

`int`

--->`list<unknown>`

(`row_at`

`matrix<unknown>`

,`int`

) --->`list<unknown>`

#### Result:

returns the row at a num_line (right-hand operand)

#### Examples:

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

#### See also:

`rows_list`

#### Possible use:

(`rows_list`

`matrix<unknown>`

) --->`list<list<unknown>>`

#### Result:

returns a list of the rows of the matrix, with each row as a list of elements

#### Examples:

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