Skip to main content
Version: 1.8.2-RC1

Operators (A to A)


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


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


Comparison operators

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


-, ::, +, accumulate, all_match, among, at, cartesian_product, collect, contains, contains_all, contains_any, contains_key, count, empty, every, first, first_with, get, group_by, in, index_by, inter, interleave, 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, remove_duplicates, reverse, shuffle, sort_by, split, split_in, split_using, sum, sum_of, union, variance_of, where, with_max_of, with_min_of,


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

horizontal, stack, vertical,


edge

edge_between, strahler,


diff, diff2,


copy_file, crs, csv_file, delete_file, dxf_file, evaluate_sub_model, file_exists, folder, folder_exists, gaml_file, geojson_file, get, gif_file, gml_file, graph6_file, graphdimacs_file, graphdot_file, graphgexf_file, graphgml_file, graphml_file, graphtsplib_file, grid_file, image_file, is_csv, is_dxf, is_gaml, is_geojson, is_gif, is_gml, is_graph6, is_graphdimacs, is_graphdot, is_graphgexf, is_graphgml, is_graphml, is_graphtsplib, is_grid, is_image, is_json, is_obj, is_osm, is_pgm, is_property, 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, read, rename_file, saved_simulation_file, shape_file, step_sub_model, svg_file, text_file, threeds_file, unzip, writable, xml_file, zip,


conversation, message,


GamaMaterialType

material,


GamaMetaType

type_of,


Gen*

add_attribute, add_census_file, add_mapper, add_marginals, add_range_attribute, with_generation_algo,


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, as_spatial_graph, 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_random_graph, generate_watts_strogatz, girvan_newman_clustering, grid_cells_to_graph, in_degree_of, in_edges_of, k_spanning_tree_clustering, label_propagation_clustering, layout_circle, layout_force, layout_force_FR, layout_force_FR_indexed, layout_grid, 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_k_shortest_path_algorithm, with_shortest_path_algorithm, with_weights,


as_4_grid, as_grid, as_hexagonal_grid, cell_at, cells_in, cells_overlapping, field, grid_at, neighbors_of, path_between, points_in, values_in,


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, where, where, with_max_of, with_min_of,


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


as_map, create_map, index_of, last_index_of,


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


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


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


Random operators

binomial, flip, gamma_density, gamma_rnd, gamma_trunc_rnd, gauss, generate_terrain, lognormal_density, lognormal_rnd, lognormal_trunc_rnd, poisson, rnd, rnd_choice, sample, shuffle, skew_gauss, truncated_gauss, weibull_density, weibull_rnd, weibull_trunc_rnd,


ReverseOperators

restore_simulation, restore_simulation_from_file, save_simulation, serialize, serialize_agent,


Shape

arc, box, circle, cone, cone3D, cross, cube, curve, cylinder, ellipse, elliptical_arc, 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_covering, agents_crossing, agents_inside, agents_overlapping, agents_partially_overlapping, agents_touching, angle_between, any_location_in, arc, around, as_4_grid, as_driving_graph, as_grid, as_hexagonal_grid, at_distance, at_location, box, centroid, circle, clean, clean_network, closest_points_with, closest_to, closest_tob, cone, cone3D, convex_hull, covering, covers, cross, crosses, crossing, crs, CRS_transform, cube, curve, cylinder, direction_between, disjoint_from, distance_between, distance_to, ellipse, elliptical_arc, 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_overlapping, 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, touching, 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_covering, agents_crossing, agents_inside, agents_overlapping, agents_partially_overlapping, agents_touching, at_distance, closest_to, covering, crossing, farthest_to, inside, neighbors_at, neighbors_of, overlapping, partially_overlapping, touching,


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,


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, correlation, covariance, dbscan, distribution_of, distribution2d_of, dtw, durbin_watson, frequency_of, gamma, gamma_distribution, gamma_distribution_complemented, geometric_mean, gini, harmonic_mean, hierarchical_clustering, incomplete_beta, incomplete_gamma, incomplete_gamma_complement, kmeans, kurtosis, log_gamma, max, mean, mean_deviation, 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, skewness, split, split_in, split_using, standard_deviation, student_area, student_t_inverse, sum, t_test, variance,


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


SubModel

load_sub_model,


System

., choose, command, copy, copy_to_clipboard, dead, enter, eval_gaml, every, is_error, is_reachable, is_warning, user_confirm, user_input_dialog, wizard, wizard_page,


date, string,


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


User control operators

choose, enter, user_confirm, user_input_dialog, wizard, wizard_page,


Operators


-

Possible uses:

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

Result:

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

Comment:

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

Special cases:

  • if both operands are containers and the right operand is empty, - returns the left operand
  • if the left operand is a species and the right operand is an agent of the species, - returns a list containing all the agents of the species minus this agent
  • if one operand is a color and the other an integer, returns a new color resulting from the subtraction of each component of the color with the right operand
rgb var18 <- rgb([255, 128, 32]) - 3; // var18 equals rgb([252,125,29])
  • if both operands are containers, returns a new list in which all the elements of the right operand have been removed from the left one
list<int> var19 <- [1,2,3,4,5,6] - [2,4,9]; // var19 equals [1,3,5,6] 
list<int> var20 <- [1,2,3,4,5,6] - [0,8]; // var20 equals [1,2,3,4,5,6]
  • if both operands are colors, returns a new color resulting from the subtraction of the two operands, component by component
rgb var21 <- rgb([255, 128, 32]) - rgb('red'); // var21 equals rgb([0,128,32])
  • if both operands are dates, returns the duration in seconds between date2 and date1. To obtain a more precise duration, in milliseconds, use milliseconds_between(date1, date2)
float var22 <- date('2000-01-02') - date('2000-01-01'); // var22 equals 86400
  • if the left operand is a list and the right operand is an object of any type (except list), - returns a list containing the elements of the left operand minus the first occurence of this object
list<int> var23 <- [1,2,3,4,5,6,2] - 2; // var23 equals [1,3,4,5,6,2] 
list<int> var24 <- [1,2,3,4,5,6] - 0; // var24 equals [1,2,3,4,5,6]
  • if one operand is a matrix and the other a number (float or int), performs a normal arithmetic difference of the number with each element of the matrix (results are float if the number is a float.
matrix var25 <- 3.5 - matrix([[2,5],[3,4]]); // var25 equals matrix([[1.5,-1.5],[0.5,-0.5]])
  • if left-hand operand is a point and the right-hand a number, returns a new point with each coordinate as the difference of the operand coordinate with this number.
point var26 <- {1, 2} - 4.5; // var26 equals {-3.5, -2.5, -4.5} 
point var27 <- {1, 2} - 4; // var27 equals {-3.0,-2.0,-4.0}
  • if the right-operand is a list of points, geometries or agents, returns the geometry resulting from the difference between the left-geometry and all of the right-geometries
geometry var28 <- rectangle(10,10) - [circle(2), square(2)]; // var28 equals rectangle(10,10) - (circle(2) + square(2))
  • if both operands are numbers, performs a normal arithmetic difference and returns a float if one of them is a float.
int var29 <- 1 - 1; // var29 equals 0
  • if both operands are a point, a geometry or an agent, returns the geometry resulting from the difference between both geometries
geometry var30 <- geom1 - geom2; // var30 equals a geometry corresponding to difference between geom1 and geom2
  • if both operands are points, returns their difference (coordinates per coordinates).
point var31 <- {1, 2} - {4, 5}; // var31 equals {-3.0, -3.0}
  • if one of the operands is a date and the other a number, returns a date corresponding to the date minus the given number as duration (in seconds)
date var32 <- date('2000-01-01') - 86400; // var32 equals date('1999-12-31')
  • if the left-hand operand is a geometry and the right-hand operand a float, returns a geometry corresponding to the left-hand operand (geometry, agent, point) reduced by the right-hand operand distance
geometry var33 <- shape - 5; // var33 equals a geometry corresponding to the geometry of the agent applying the operator reduced by a distance of 5

Examples:

point var0 <- -{3.0,5.0}; // var0 equals {-3.0,-5.0} 
point var1 <- -{1.0,6.0,7.0}; // var1 equals {-1.0,-6.0,-7.0}
point var2 <- {2.0,3.0,4.0} - 1; // var2 equals {1.0,2.0,3.0}
float var3 <- 1.0 - 1.0; // var3 equals 0.0
float var4 <- 3.7 - 1.2; // var4 equals 2.5
float var5 <- 3.0 - 1.2; // var5 equals 1.8
matrix var6 <- (10.0 - (3.0 as_matrix({2,3}))); // var6 equals matrix([[7.0,7.0,7.0],[7.0,7.0,7.0]])
float var7 <- 1 - 1.0; // var7 equals 0.0
float var8 <- 3 - 1.2; // var8 equals 1.8
date var9 <- date('2000-01-01') - 86400; // var9 equals date('1999-12-31')
map var10 <- ['a'::1,'b'::2] - ['b'::2]; // var10 equals ['a'::1]
map var11 <- ['a'::1,'b'::2] - ['b'::2,'c'::3]; // var11 equals ['a'::1]
int var12 <- - (-56); // var12 equals 56
float var13 <- 1.0 - 1; // var13 equals 0.0
float var14 <- 3.7 - 1; // var14 equals 2.7
float var15 <- 3.0 - 1; // var15 equals 2.0
map var16 <- ['a'::1,'b'::2] - ('b'::2); // var16 equals ['a'::1]
map var17 <- ['a'::1,'b'::2] - ('c'::3); // var17 equals ['a'::1,'b'::2]

See also: +, milliseconds_between, -, *, /,


:

Possible uses:

  • unknown : unknown ---> unknown
  • : (unknown , unknown) ---> unknown

Result:

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

Examples:

list<string> var0 <- [10, 19, 43, 12, 7, 22] collect ((each > 20) ? 'above' : 'below'); // var0 equals ['below', 'below', 'above', 'below', 'below', 'above']

See also: ?,


::

Possible uses:

  • any expression :: any expression ---> pair
  • :: (any expression , any expression) ---> pair

Result:

produces a new pair combining the left and the right operands

Special cases:

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

!

Possible uses:

  • ! (bool) ---> bool

Result:

opposite boolean value.

Special cases:

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

Examples:

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

See also: bool, and, or,


!=

Possible uses:

  • date != date ---> bool
  • != (date , date) ---> bool
  • int != float ---> bool
  • != (int , float) ---> bool
  • float != float ---> bool
  • != (float , float) ---> bool
  • float != int ---> bool
  • != (float , int) ---> bool
  • unknown != unknown ---> bool
  • != (unknown , unknown) ---> bool

Result:

true if both operands are different, false otherwise

Examples:

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

See also: =, >, <, >=, <=,


?

Possible uses:

  • bool ? any expression ---> unknown
  • ? (bool , any expression) ---> unknown

Result:

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

Comment:

These functional tests can be combined together.

Examples:

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

See also: :,


/

Possible uses:

  • rgb / int ---> rgb
  • / (rgb , int) ---> rgb
  • float / float ---> float
  • / (float , float) ---> float
  • point / float ---> point
  • / (point , float) ---> point
  • field / float ---> field
  • / (field , float) ---> field
  • point / int ---> point
  • / (point , int) ---> point
  • int / int ---> float
  • / (int , int) ---> float
  • matrix<unknown> / int ---> matrix
  • / (matrix<unknown> , int) ---> matrix
  • field / int ---> field
  • / (field , int) ---> field
  • int / float ---> float
  • / (int , float) ---> float
  • float / int ---> float
  • / (float , int) ---> float
  • matrix<unknown> / float ---> matrix
  • / (matrix<unknown> , float) ---> matrix
  • rgb / float ---> rgb
  • / (rgb , float) ---> rgb
  • matrix<unknown> / matrix ---> matrix
  • / (matrix<unknown> , matrix) ---> matrix

Result:

Returns the division of the two operands.

Special cases:

  • if the right-hand operand is equal to zero, raises a "Division by zero" exception
  • if one operand is a color and the other an integer, returns a new color resulting from the division of each component of the color by the right operand
rgb var0 <- rgb([255, 128, 32]) / 2; // var0 equals rgb([127,64,16])
  • if the left operand is a point, returns a new point with coordinates divided by the right operand
point var1 <- {5, 7.5} / 2.5; // var1 equals {2, 3} 
point var2 <- {2,5} / 4; // var2 equals {0.5,1.25}
  • if both operands are numbers (float or int), performs a normal arithmetic division and returns a float.
float var3 <- 3 / 5.0; // var3 equals 0.6
  • if one operand is a color and the other a double, returns a new color resulting from the division of each component of the color by the right operand. The result on each component is then truncated.
rgb var4 <- rgb([255, 128, 32]) / 2.5; // var4 equals rgb([102,51,13])

See also: *, +, -,


.

Possible uses:

  • agent . any expression ---> unknown
  • . (agent , any expression) ---> unknown

Result:

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

Special cases:

  • if the agent is nil or dead, throws an exception
  • if the left operand is an agent, it evaluates of the expression (right-hand operand) in the scope the given agent
unknown var0 <- agent1.location; // var0 equals the location of the agent agent1

.

Possible uses:

  • matrix . matrix ---> matrix
  • . (matrix , matrix) ---> matrix

Special cases:

  • if both operands are matrix, returns the dot product of them
matrix var0 <- matrix([[1,1],[1,2]]) . matrix([[1,1],[1,2]]); // var0 equals matrix([[2,3],[3,5]])

^

Possible uses:

  • int ^ int ---> float
  • ^ (int , int) ---> float
  • int ^ float ---> float
  • ^ (int , float) ---> float
  • float ^ int ---> float
  • ^ (float , int) ---> float
  • float ^ float ---> float
  • ^ (float , float) ---> float

Result:

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

Special cases:

  • if the right-hand operand is equal to 0, returns 1
  • if it is equal to 1, returns the left-hand operand.
  • Various examples of power
float var0 <- 2 ^ 3; // var0 equals 8.0

Examples:

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

See also: *, sqrt,


@

Same signification as at


*

Possible uses:

  • matrix<unknown> * float ---> matrix
  • * (matrix<unknown> , float) ---> matrix
  • geometry * float ---> geometry
  • * (geometry , float) ---> geometry
  • float * matrix ---> matrix
  • * (float , matrix) ---> matrix
  • matrix<unknown> * matrix ---> matrix
  • * (matrix<unknown> , matrix) ---> matrix
  • int * int ---> int
  • * (int , int) ---> int
  • field * float ---> field
  • * (field , float) ---> field
  • rgb * int ---> rgb
  • * (rgb , int) ---> rgb
  • rgb * float ---> rgb
  • * (rgb , float) ---> rgb
  • int * matrix ---> matrix
  • * (int , matrix) ---> matrix
  • matrix<unknown> * int ---> matrix
  • * (matrix<unknown> , int) ---> matrix
  • point * point ---> float
  • * (point , point) ---> float
  • geometry * point ---> geometry
  • * (geometry , point) ---> geometry
  • int * float ---> float
  • * (int , float) ---> float
  • float * int ---> float
  • * (float , int) ---> float
  • point * float ---> point
  • * (point , float) ---> point
  • point * int ---> point
  • * (point , int) ---> point
  • float * float ---> float
  • * (float , float) ---> float
  • field * int ---> field
  • * (field , int) ---> field

Result:

Returns the product of the two operands.

Special cases:

  • if the left-hand operand is a geometry and the right-hand operand a float, returns a geometry corresponding to the left-hand operand (geometry, agent, point) scaled by the right-hand operand coefficient
geometry var1 <- circle(10) * 2; // var1 equals circle(20) 
geometry var2 <- (circle(10) * 2).location with_precision 9; // var2 equals (circle(20)).location with_precision 9
float var3 <- (circle(10) * 2).height with_precision 9; // var3 equals (circle(20)).height with_precision 9
  • if both operands are numbers (float or int), performs a normal arithmetic product and returns a float if one of them is a float.
int var4 <- 1 * 1; // var4 equals 1
  • if one operand is a color and the other an integer, returns a new color resulting from the product of each component of the color with the right operand (with a maximum value at 255)
rgb var5 <- rgb([255, 128, 32]) * 2; // var5 equals rgb([255,255,64])
  • if one operand is a color and the other a float, returns a new color resulting from the product of each component of the color with the right operand (with a maximum value at 255)
rgb var6 <- rgb([255, 128, 32]) * 2.0; // var6 equals rgb([255,255,64])
  • if one operand is a matrix and the other a number (float or int), performs a normal arithmetic product of the number with each element of the matrix (results are float if the number is a float.
matrix var7 <- 2 * matrix([[2,5],[3,4]]); // var7 equals matrix([[4,10],[6,8]])
  • if both operands are points, returns their scalar product
float var8 <- {2,5} * {4.5, 5}; // var8 equals 34.0
  • if the left-hand operand is a geometry and the right-hand operand a point, returns a geometry corresponding to the left-hand operand (geometry, agent, point) scaled by the right-hand operand coefficients in the 3 dimensions
geometry var9 <- shape * {0.5,0.5,2}; // var9 equals a geometry corresponding to the geometry of the agent applying the operator scaled by a coefficient of 0.5 in x, 0.5 in y and 2 in z
  • if the left-hand operator is a point and the right-hand a number, returns a point with coordinates multiplied by the number
point var10 <- {2,5} * 4; // var10 equals {8.0, 20.0} 
point var11 <- {2, 4} * 2.5; // var11 equals {5.0, 10.0}

Examples:

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

See also: +, -, /,


+

Possible uses:

  • field + matrix ---> field
  • + (field , matrix) ---> field
  • field + int ---> field
  • + (field , int) ---> field
  • point + int ---> point
  • + (point , int) ---> point
  • string + unknown ---> string
  • + (string , unknown) ---> string
  • map + map ---> map
  • + (map , map) ---> map
  • geometry + geometry ---> geometry
  • + (geometry , geometry) ---> geometry
  • container + unknown ---> list
  • + (container , unknown) ---> list
  • matrix<unknown> + int ---> matrix
  • + (matrix<unknown> , int) ---> matrix
  • float + float ---> float
  • + (float , float) ---> float
  • matrix<unknown> + matrix ---> matrix
  • + (matrix<unknown> , matrix) ---> matrix
  • point + point ---> point
  • + (point , point) ---> point
  • rgb + int ---> rgb
  • + (rgb , int) ---> rgb
  • rgb + rgb ---> rgb
  • + (rgb , rgb) ---> rgb
  • geometry + float ---> geometry
  • + (geometry , float) ---> geometry
  • field + float ---> field
  • + (field , float) ---> field
  • int + float ---> float
  • + (int , float) ---> float
  • point + float ---> point
  • + (point , float) ---> point
  • string + string ---> string
  • + (string , string) ---> string
  • int + int ---> int
  • + (int , int) ---> int
  • container + container ---> container
  • + (container , container) ---> container
  • float + int ---> float
  • + (float , int) ---> float
  • date + float ---> date
  • + (date , float) ---> date
  • float + matrix ---> matrix
  • + (float , matrix) ---> matrix
  • int + matrix ---> matrix
  • + (int , matrix) ---> matrix
  • date + int ---> date
  • + (date , int) ---> date
  • map + pair ---> map
  • + (map , pair) ---> map
  • matrix<unknown> + float ---> matrix
  • + (matrix<unknown> , float) ---> matrix
  • date + string ---> string
  • + (date , string) ---> string
  • + (geometry, float, int) ---> geometry
  • + (geometry, float, bool) ---> geometry
  • + (geometry, float, int, int) ---> geometry
  • + (geometry, float, int, int, bool) ---> geometry

Result:

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

Special cases:

  • if one of the operands is nil, + throws an error
  • if both operands are species, returns a special type of list called meta-population
  • if the left-hand operand is a geometry and the right-hand operands a float, an integer, one of #round, #square or #flat and a boolean, returns a geometry corresponding to the left-hand operand (geometry, agent, point) enlarged by the first right-hand operand (distance), using a number of segments equal to the second right-hand operand and a flat, square or round end cap style and single sided is the boolean is true
geometry var9 <- line([{10,10}, {50,50}]) + (5,32,#round, true); // var9 equals A ploygon corresponding to the buffer generated
  • if the left-hand operand is a string, returns the concatenation of the two operands (the left-hand one beind casted into a string)
string var10 <- "hello " + 12; // var10 equals "hello 12"
  • if the right-operand is a point, a geometry or an agent, returns the geometry resulting from the union between both geometries
geometry var11 <- geom1 + geom2; // var11 equals a geometry corresponding to union between geom1 and geom2
  • if the right operand is an object of any type (except a container), + returns a list of the elements of the left operand, to which this object has been added
list<int> var12 <- [1,2,3,4,5,6] + 2; // var12 equals [1,2,3,4,5,6,2] 
list<int> var13 <- [1,2,3,4,5,6] + 0; // var13 equals [1,2,3,4,5,6,0]
  • if both operands are points, returns their sum.
point var14 <- {1, 2} + {4, 5}; // var14 equals {5.0, 7.0}
  • if one operand is a color and the other an integer, returns a new color resulting from the sum of each component of the color with the right operand
rgb var15 <- rgb([255, 128, 32]) + 3; // var15 equals rgb([255,131,35])
  • if both operands are colors, returns a new color resulting from the sum of the two operands, component by component
rgb var16 <- rgb([255, 128, 32]) + rgb('red'); // var16 equals rgb([255,128,32])
  • if the left-hand operand is a geometry and the right-hand operands a float and an integer, returns a geometry corresponding to the left-hand operand (geometry, agent, point) enlarged by the first right-hand operand (distance), using a number of segments equal to the second right-hand operand
geometry var17 <- circle(5) + (5,32); // var17 equals circle(10)
  • if the left-hand operand is a geometry and the right-hand operand a float, returns a geometry corresponding to the left-hand operand (geometry, agent, point) enlarged by the right-hand operand distance. The number of segments used by default is 8 and the end cap style is #round
geometry var18 <- circle(5) + 5; // var18 equals circle(10)
  • if the left-hand operand is a point and the right-hand a number, returns a new point with each coordinate as the sum of the operand coordinate with this number.
point var19 <- {1, 2} + 4.5; // var19 equals {5.5, 6.5,4.5}
  • if the left-hand and right-hand operand are a string, returns the concatenation of the two operands
string var20 <- "hello " + "World"; // var20 equals "hello World"
  • if the left-hand operand is a geometry and the right-hand operands a float, an integer and one of #round, #square or #flat, returns a geometry corresponding to the left-hand operand (geometry, agent, point) enlarged by the first right-hand operand (distance), using a number of segments equal to the second right-hand operand and a flat, square or round end cap style
geometry var21 <- circle(5) + (5,32,#round); // var21 equals circle(10)
  • if both operands are numbers (float or int), performs a normal arithmetic sum and returns a float if one of them is a float.
int var22 <- 1 + 1; // var22 equals 2
  • if both operands are list, +returns the concatenation of both lists.
list<int> var23 <- [1,2,3,4,5,6] + [2,4,9]; // var23 equals [1,2,3,4,5,6,2,4,9] 
list<int> var24 <- [1,2,3,4,5,6] + [0,8]; // var24 equals [1,2,3,4,5,6,0,8]
  • if one operand is a matrix and the other a number (float or int), performs a normal arithmetic sum of the number with each element of the matrix (results are float if the number is a float.
matrix var25 <- 3.5 + matrix([[2,5],[3,4]]); // var25 equals matrix([[5.5,8.5],[6.5,7.5]])
  • if one of the operands is a date and the other a number, returns a date corresponding to the date plus the given number as duration (in seconds)
date var26 <- date('2000-01-01') + 86400; // var26 equals date('2000-01-02')
  • if the left-hand operand is a geometry and the right-hand operands a float and a boolean, returns a geometry corresponding to the left-hand operand (geometry, agent, point) enlarged by the first right-hand operand (distance), single sided is the boolean is true
geometry var27 <- line([{10,10}, {50,50}]) + (5, true); // var27 equals A ploygon corresponding to the buffer generated

Examples:

point var0 <- {1, 2} + 4; // var0 equals {5.0, 6.0,4.0} 
map var1 <- ['a'::1,'b'::2] + ['c'::3]; // var1 equals ['a'::1,'b'::2,'c'::3]
map var2 <- ['a'::1,'b'::2] + [5::3.0]; // var2 equals ['a'::1,'b'::2,5::3.0]
float var3 <- 1.0 + 1; // var3 equals 2.0
float var4 <- 1.0 + 2.5; // var4 equals 3.5
date var5 <- date('2016-01-01 00:00:01') + 86400; // var5 equals date('2016-01-02 00:00:01')
map var6 <- ['a'::1,'b'::2] + ('c'::3); // var6 equals ['a'::1,'b'::2,'c'::3]
map var7 <- ['a'::1,'b'::2] + ('c'::3); // var7 equals ['a'::1,'b'::2,'c'::3]
string var8 <- date('2000-01-01 00:00:00') + '_Test'; // var8 equals '2000-01-01 00:00:00_Test'

See also: -, *, /,


<

Possible uses:

  • string < string ---> bool
  • < (string , string) ---> bool
  • date < date ---> bool
  • < (date , date) ---> bool
  • point < point ---> bool
  • < (point , point) ---> bool
  • int < float ---> bool
  • < (int , float) ---> bool
  • float < int ---> bool
  • < (float , int) ---> bool
  • float < float ---> bool
  • < (float , float) ---> bool
  • int < int ---> bool
  • < (int , int) ---> bool

Result:

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

Special cases:

  • if one of the operands is nil, returns false
  • if both operands are String, uses a lexicographic comparison of two strings
bool var0 <- 'abc' < 'aeb'; // var0 equals true
  • if both operands are points, returns true if and only if the left component (x) of the left operand if less than or equal to x of the right one and if the right component (y) of the left operand is greater than or equal to y of the right one.
bool var1 <- {5,7} < {4,6}; // var1 equals false 
bool var2 <- {5,7} < {4,8}; // var2 equals false

Examples:

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

See also: >, >=, <=, =, !=,


<=

Possible uses:

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

Result:

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

Special cases:

  • if one of the operands is nil, returns false
  • if both operands are String, uses a lexicographic comparison of two strings
bool var0 <- 'abc' <= 'aeb'; // var0 equals true
  • if both operands are points, returns true if and only if the left component (x) of the left operand if less than or equal to x of the right one and if the right component (y) of the left operand is greater than or equal to y of the right one.
bool var1 <- {5,7} <= {4,6}; // var1 equals false 
bool var2 <- {5,7} <= {4,8}; // var2 equals false

Examples:

bool var3 <- 3.5 <= 3.5; // var3 equals true 
bool var4 <- 7.0 <= 7; // var4 equals true
bool var5 <- 3 <= 2.5; // var5 equals false
bool var6 <- (#now <= (#now minus_hours 1)); // var6 equals false
bool var7 <- 3 <= 7; // var7 equals true

See also: >, <, >=, =, !=,


=

Possible uses:

  • date = date ---> bool
  • = (date , date) ---> bool
  • float = int ---> bool
  • = (float , int) ---> bool
  • int = int ---> bool
  • = (int , int) ---> bool
  • float = float ---> bool
  • = (float , float) ---> bool
  • unknown = unknown ---> bool
  • = (unknown , unknown) ---> bool
  • int = float ---> bool
  • = (int , float) ---> bool

Result:

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

Special cases:

  • if both operands are any kind of objects, returns true if they are identical (i.e., the same object) or equal (comparisons between nil values are permitted)
bool var0 <- [2,3] = [2,3]; // var0 equals true

Examples:

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

See also: !=, >, <, >=, <=,


>

Possible uses:

  • string > string ---> bool
  • > (string , string) ---> bool
  • int > int ---> bool
  • > (int , int) ---> bool
  • int > float ---> bool
  • > (int , float) ---> bool
  • float > float ---> bool
  • > (float , float) ---> bool
  • point > point ---> bool
  • > (point , point) ---> bool
  • date > date ---> bool
  • > (date , date) ---> bool
  • float > int ---> bool
  • > (float , int) ---> bool

Result:

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

Special cases:

  • if one of the operands is nil, returns false
  • if both operands are String, uses a lexicographic comparison of two strings
bool var0 <- 'abc' > 'aeb'; // var0 equals false
  • if both operands are points, returns true if and only if the left component (x) of the left operand if greater than x of the right one and if the right component (y) of the left operand is greater than y of the right one.
bool var1 <- {5,7} > {4,6}; // var1 equals true 
bool var2 <- {5,7} > {4,8}; // var2 equals false

Examples:

bool var3 <- 13.0 > 7.0; // var3 equals true 
bool var4 <- 3 > 2.5; // var4 equals true
bool var5 <- 3.5 > 7.6; // var5 equals false
bool var6 <- (#now > (#now minus_hours 1)); // var6 equals true
bool var7 <- 3.5 > 7; // var7 equals false

See also: <, >=, <=, =, !=,


>=

Possible uses:

  • string >= string ---> bool
  • >= (string , string) ---> bool
  • float >= int ---> bool
  • >= (float , int) ---> bool
  • date >= date ---> bool
  • >= (date , date) ---> bool
  • int >= int ---> bool
  • >= (int , int) ---> bool
  • point >= point ---> bool
  • >= (point , point) ---> bool
  • int >= float ---> bool
  • >= (int , float) ---> bool
  • float >= float ---> bool
  • >= (float , float) ---> bool

Result:

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

Special cases:

  • if one of the operands is nil, returns false
  • if both operands are string, uses a lexicographic comparison of the two strings
bool var0 <- 'abc' >= 'aeb'; // var0 equals false 
bool var1 <- 'abc' >= 'abc'; // var1 equals true
  • if both operands are points, returns true if and only if the left component (x) of the left operand if greater or equal than x of the right one and if the right component (y) of the left operand is greater than or equal to y of the right one.
bool var2 <- {5,7} >= {4,6}; // var2 equals true 
bool var3 <- {5,7} >= {4,8}; // var3 equals false

Examples:

bool var4 <- 3.5 >= 7; // var4 equals false 
bool var5 <- #now >= #now minus_hours 1; // var5 equals true
bool var6 <- 3 >= 7; // var6 equals false
bool var7 <- 3 >= 2.5; // var7 equals true
bool var8 <- 3.5 >= 3.5; // var8 equals true

See also: >, <, <=, =, !=,


abs

Possible uses:

  • abs (float) ---> float
  • abs (int) ---> int

Result:

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

Examples:

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

accumulate

Possible uses:

  • container accumulate any expression ---> list
  • accumulate (container , any expression) ---> list

Result:

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

Comment:

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

Examples:

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

See also: collect,


acos

Possible uses:

  • acos (float) ---> float
  • acos (int) ---> float

Result:

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

Special cases:

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

Examples:

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

See also: asin, atan, cos,


action

Possible uses:

  • action (any) ---> action

Result:

casts the operand in a action object.


add_3Dmodel

Possible uses:

  • add_3Dmodel (kml, point, float, float, string) ---> kml
  • add_3Dmodel (kml, point, float, float, string, date, date) ---> kml

Result:

the kml export manager with new 3D model: specify the 3D model (collada) to add to the kml

See also: add_geometry, add_icon, add_label,


add_attribute

Possible uses:

  • add_attribute (gen_population_generator, string, any GAML type, list) ---> gen_population_generator
  • add_attribute (gen_population_generator, string, any GAML type, list, bool) ---> gen_population_generator
  • add_attribute (gen_population_generator, string, any GAML type, list, string, any GAML type) ---> gen_population_generator
  • add_attribute (gen_population_generator, string, any GAML type, list, bool, string, any GAML type) ---> gen_population_generator

Result:

add an attribute defined by its name (string), its datatype (type), its list of values (list) to a population_generator add an attribute defined by its name (string), its datatype (type), its list of values (list) and attributeType name (type of the attribute among "range" and "unique") to a population_generator add an attribute defined by its name (string), its datatype (type), its list of values (list) and record name (name of the attribute to record) to a population_generator add an attribute defined by its name (string), its datatype (type), its list of values (list) to a population_generator

Examples:

add_attribute(pop_gen, "Sex", string,["Man", "Woman"]) 
add_attribute(pop_gen, "iris", string, liste_iris, "unique")
add_attribute(pop_gen, "iris", string,liste_iris, "unique", "P13_POP")
add_attribute(pop_gen, "Sex", string,["Man", "Woman"])

add_census_file

Possible uses:

  • add_census_file (gen_population_generator, string, string, string, int, int) ---> gen_population_generator

Result:

add a census data file defined by its path (string), its type ("ContingencyTable", "GlobalFrequencyTable", "LocalFrequencyTable" or "Sample"), its separator (string), the index of the first row of data (int) and the index of the first column of data (int) to a population_generator

Examples:

add_census_file(pop_gen, "../data/Age_Couple.csv", "ContingencyTable", ";", 1, 1)

add_days

Same signification as plus_days


add_edge

Possible uses:

  • graph add_edge pair ---> graph
  • add_edge (graph , pair) ---> graph

Result:

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

Comment:

WARNING / side effect: this operator modifies the operand and does not create a new graph. If the edge already exists, the graph is unchanged

Examples:

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

See also: add_node, graph,


add_geometry

Possible uses:

  • add_geometry (kml, geometry, float, rgb) ---> kml
  • add_geometry (kml, geometry, rgb, rgb) ---> kml
  • add_geometry (kml, geometry, float, rgb, rgb) ---> kml
  • add_geometry (kml, geometry, float, rgb, rgb, date) ---> kml
  • add_geometry (kml, geometry, float, rgb, rgb, date, date) ---> kml

Result:

Define the kml export manager with new geometry

See also: add_3Dmodel, add_icon, add_label,


add_hours

Same signification as plus_hours


add_icon

Possible uses:

  • add_icon (kml, point, float, float, string) ---> kml
  • add_icon (kml, point, float, float, string, date, date) ---> kml

Result:

Define the kml export manager with new icons

See also: add_geometry, add_icon,


add_mapper

Possible uses:

  • add_mapper (gen_population_generator, string, any GAML type, map) ---> gen_population_generator
  • add_mapper (gen_population_generator, string, any GAML type, map, bool) ---> gen_population_generator

Result:

add a mapper between source of data for a attribute to a population_generator. A mapper is defined by the name of the attribute, the datatype of attribute (type), the corresponding value (map<list,list>) and the type of attribute ("unique" or "range") add a mapper between source of data for a attribute to a population_generator. A mapper is defined by the name of the attribute, the datatype of attribute (type), the corresponding value (map<list,list>) and the type of attribute ("unique" or "range")

Examples:

 add_mapper(pop_gen, "Age", int, [["0 to 18"]::["1 to 10","11 to 18"], ["18 to 100"]::["18 to 50","51 to 100"] , "range"); 
add_mapper(pop_gen, "Age", int, [["0 to 18"]::["1 to 10","11 to 18"], ["18 to 100"]::["18 to 50","51 to 100"] , "range");

add_marginals

Possible uses:

  • gen_population_generator add_marginals list ---> gen_population_generator
  • add_marginals (gen_population_generator , list) ---> gen_population_generator

Result:

add a list of marginals (name of the attributes) to fit the population with, in any CO based algorithm

Examples:

add_marginals(pop_gen, ["gender","age"])

add_minutes

Same signification as plus_minutes


add_months

Same signification as plus_months


add_ms

Same signification as plus_ms


add_node

Possible uses:

  • graph add_node geometry ---> graph
  • add_node (graph , geometry) ---> graph

Result:

adds a node in a graph.

Comment:

WARNING / side effect: this operator modifies the operand and does not create a new graph

Examples:

graph var0 <- graph add_node node(0) ; // var0 equals the graph, to which node(0) has been added

See also: add_edge, graph,


add_point

Possible uses:

  • geometry add_point point ---> geometry
  • add_point (geometry , point) ---> geometry

Result:

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

Examples:

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

add_range_attribute

Possible uses:

  • add_range_attribute (gen_population_generator, string, list, int, int) ---> gen_population_generator

Result:

add a rangee attribute defined by its name (string), the list of ranges (list) to a population_generator

Examples:

add_attribute(pop_gen, "Sex", string,["Man", "Woman"])

add_seconds

Same signification as +


add_values

Possible uses:

  • predicate add_values map ---> predicate
  • add_values (predicate , map) ---> predicate

Result:

add a new value to the map of the given predicate

Examples:

predicate add_values ["time"::10]

add_weeks

Same signification as plus_weeks


add_years

Same signification as plus_years


adjacency

Possible uses:

  • adjacency (graph) ---> matrix<float>

Result:

adjacency matrix of the given graph.


after

Possible uses:

  • after (date) ---> bool
  • any expression after date ---> bool
  • after (any expression , date) ---> bool

Result:

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

Examples:

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

agent

Possible uses:

  • agent (any) ---> agent

Result:

casts the operand in a agent object.


agent_closest_to

Possible uses:

  • agent_closest_to (unknown) ---> agent

Result:

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

Comment:

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

Examples:

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

See also: neighbors_at, neighbors_of, agents_inside, agents_overlapping, closest_to, inside, overlapping,


agent_farthest_to

Possible uses:

  • agent_farthest_to (unknown) ---> agent

Result:

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

Comment:

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

Examples:

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

See also: neighbors_at, neighbors_of, agents_inside, agents_overlapping, closest_to, inside, overlapping, agent_closest_to, farthest_to,


agent_from_geometry

Possible uses:

  • path agent_from_geometry geometry ---> agent
  • agent_from_geometry (path , geometry) ---> agent

Result:

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

Special cases:

  • if the left-hand operand is nil, returns nil

Examples:

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

See also: path,


agent_intersecting

Same signification as agents_overlapping


agents_at_distance

Possible uses:

  • agents_at_distance (float) ---> list

Result:

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

Examples:

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

See also: neighbors_at, neighbors_of, agent_closest_to, agents_inside, closest_to, inside, overlapping, at_distance,


agents_covering

Possible uses:

  • agents_covering (unknown) ---> list<agent>

Result:

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

Examples:

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

See also: agent_closest_to, agents_overlapping, closest_to, inside, overlapping,


agents_crossing

Possible uses:

  • agents_crossing (unknown) ---> list<agent>

Result:

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

Examples:

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

See also: agent_closest_to, agents_overlapping, closest_to, inside, overlapping,


agents_inside

Possible uses:

  • agents_inside (unknown) ---> list<agent>

Result:

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

Examples:

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

See also: agent_closest_to, agents_overlapping, closest_to, inside, overlapping,


agents_overlapping

Possible uses:

  • agents_overlapping (unknown) ---> list<agent>

Result:

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

Examples:

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

See also: neighbors_at, neighbors_of, agent_closest_to, agents_inside, closest_to, inside, overlapping, at_distance,


agents_partially_overlapping

Possible uses:

  • agents_partially_overlapping (unknown) ---> list<agent>

Result:

A list of agents that partially overlap the operand (casted as a geometry).

Examples:

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

See also: agent_closest_to, agents_overlapping, closest_to, inside, overlapping,


agents_touching

Possible uses:

  • agents_touching (unknown) ---> list<agent>

Result:

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

Examples:

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

See also: agent_closest_to, agents_overlapping, closest_to, inside, overlapping,


all_indexes_of

Possible uses:

  • list all_indexes_of unknown ---> list
  • all_indexes_of (list , unknown) ---> list

Result:

all the index of all the occurences of the right operand in the left operand container

Comment:

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

Special cases:

  • if the left operand is a list, all_indexes_of returns a list of all the indexes as integers
list var0 <- [1,2,3,1,2,3] all_indexes_of 1; // var0 equals [0,3] 
list var1 <- [1,2,3,1,2,3] all_indexes_of 4; // var1 equals []

See also: index_of, last_index_of,


all_match

Possible uses:

  • container all_match any expression ---> bool
  • all_match (container , any expression) ---> bool

Result:

Returns true if all 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 all_match each.property' is strictly equivalent to '(c count each.property) = length(c)' 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, all_match throws an error

Examples:

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

See also: none_matches, one_matches, count,


all_pairs_shortest_path

Possible uses:

  • all_pairs_shortest_path (graph) ---> matrix<int>

Result:

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

Examples:

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

all_verify

Same signification as all_match


alpha_index

Possible uses:

  • alpha_index (graph) ---> float

Result:

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

Examples:

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

See also: beta_index, gamma_index, nb_cycles, connectivity_index,


among

Possible uses:

  • int among container ---> list
  • among (int , container) ---> list

Result:

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

Special cases:

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

Examples:

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

and

Possible uses:

  • bool and any expression ---> bool
  • and (bool , any expression) ---> bool

Result:

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

Comment:

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

Examples:

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

See also: bool, or, !,


and

Possible uses:

  • predicate and predicate ---> predicate
  • and (predicate , predicate) ---> predicate

Result:

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

Examples:

predicate1 and predicate2

angle_between

Possible uses:

  • angle_between (point, point, point) ---> float

Result:

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

Examples:

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

any

Same signification as one_of


any_location_in

Possible uses:

  • any_location_in (geometry) ---> point

Result:

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

Examples:

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

See also: closest_points_with, farthest_point_to, points_at,


any_point_in

Same signification as any_location_in


append_horizontally

Possible uses:

  • matrix append_horizontally matrix ---> matrix
  • append_horizontally (matrix , matrix) ---> matrix

Result:

A matrix resulting from the concatenation of the rows of the two given matrices.


append_vertically

Possible uses:

  • matrix append_vertically matrix ---> matrix
  • append_vertically (matrix , matrix) ---> matrix

Result:

A matrix resulting from the concatenation of the columns of the two given matrices.

Examples:

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

arc

Possible uses:

  • arc (float, float, float) ---> geometry
  • arc (float, float, float, bool) ---> geometry

Result:

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

Comment:

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

Special cases:

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

Examples:

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

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


around

Possible uses:

  • float around unknown ---> geometry
  • around (float , unknown) ---> geometry

Result:

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

Special cases:

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

Examples:

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

See also: circle, cone, line, link, norm, point, polygon, polyline, rectangle, square, triangle,


as

Possible uses:

  • unknown as any GAML type ---> unknown
  • as (unknown , any GAML type) ---> unknown

Result:

casting of the first argument into a given type

Comment:

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

Examples:

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

as_4_grid

Possible uses:

  • geometry as_4_grid point ---> matrix
  • as_4_grid (geometry , point) ---> matrix

Result:

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

Examples:

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

See also: as_grid, as_hexagonal_grid,


as_distance_graph

Possible uses:

  • container as_distance_graph float ---> graph
  • as_distance_graph (container , float) ---> graph
  • as_distance_graph (container, float, species) ---> graph

Result:

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

Comment:

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

Examples:

list(ant) as_distance_graph 3.0

See also: as_intersection_graph, as_edge_graph,


as_driving_graph

Possible uses:

  • container as_driving_graph container ---> graph
  • as_driving_graph (container , container) ---> graph

Result:

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

Examples:

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

See also: as_intersection_graph, as_distance_graph, as_edge_graph,


as_edge_graph

Possible uses:

  • as_edge_graph (map) ---> graph
  • as_edge_graph (container) ---> graph
  • container as_edge_graph container ---> graph
  • as_edge_graph (container , container) ---> graph
  • container as_edge_graph float ---> graph
  • as_edge_graph (container , float) ---> graph

Result:

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

Special cases:

  • if the operand is a list and a tolerance (max distance in meters to consider that 2 points are the same node) is given, the graph will be built with elements of the list as edges and two edges will be connected by a node if the distance between their extremity (first or last points) are at distance lower or equal to the tolerance
graph var0 <- as_edge_graph([line([{1,5},{12,45}]),line([{13,45},{34,56}])],1); // var0 equals a graph with two edges and three vertices
  • if the operand is a map, the graph will be built by creating edges from pairs of the map
graph var1 <- as_edge_graph([{1,5}::{12,45},{12,45}::{34,56}]); // var1 equals a graph with these three vertices and two edges
  • if the operand is a list, the graph will be built with elements of the list as edges
graph var2 <- as_edge_graph([line([{1,5},{12,45}]),line([{12,45},{34,56}])]); // var2 equals a graph with two edges and three vertices

See also: as_intersection_graph, as_distance_graph,


as_grid

Possible uses:

  • geometry as_grid point ---> matrix
  • as_grid (geometry , point) ---> matrix

Result:

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

Examples:

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

See also: as_4_grid, as_hexagonal_grid,


as_hexagonal_grid

Possible uses:

  • geometry as_hexagonal_grid point ---> list<geometry>
  • as_hexagonal_grid (geometry , point) ---> list<geometry>

Result:

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

Examples:

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

See also: as_4_grid, as_grid,


as_int

Possible uses:

  • string as_int int ---> int
  • as_int (string , int) ---> int

Result:

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

Special cases:

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

Examples:

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

See also: int,


as_intersection_graph

Possible uses:

  • container as_intersection_graph float ---> graph
  • as_intersection_graph (container , float) ---> graph
  • as_intersection_graph (container, float, species) ---> graph

Result:

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

Comment:

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

Examples:

list(ant) as_intersection_graph 0.5

See also: as_distance_graph, as_edge_graph,


as_map

Possible uses:

  • container as_map any expression ---> map
  • as_map (container , any expression) ---> map

Result:

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

Comment:

the right-hand operand should be a pair

Special cases:

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

Examples:

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

as_matrix

Possible uses:

  • unknown as_matrix point ---> matrix
  • as_matrix (unknown , point) ---> matrix

Result:

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

Comment:

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

Special cases:

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

See also: matrix,


as_path

Possible uses:

  • list<geometry> as_path graph ---> path
  • as_path (list<geometry> , graph) ---> path

Result:

create a graph path from the list of shape

Examples:

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

as_spatial_graph

Possible uses:

  • as_spatial_graph (graph) ---> msi.gama.metamodel.topology.graph.ISpatialGraph

Result:

Creates a spatial graph out of an arbitrary graph. If the argument is already a spatial graph, returns it unchanged. If it contains geometrical nodes or edges, they are kept unchanged


asin

Possible uses:

  • asin (float) ---> float
  • asin (int) ---> float

Result:

the arcsin of the operand

Special cases:

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

Examples:

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

See also: acos, atan, sin,


at

Possible uses:

  • string at int ---> string
  • at (string , int) ---> string
  • list at int ---> unknown
  • at (list , int) ---> unknown
  • matrix at point ---> unknown
  • at (matrix , point) ---> unknown
  • species at int ---> agent
  • at (species , int) ---> agent
  • container at unknown ---> unknown
  • at (container , unknown) ---> unknown

Result:

the element at the right operand index of the container

Comment:

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

Special cases:

  • if it is a file, at returns the element of the file content at the index specified by the right operand
  • if it is a population, at returns the agent at the index specified by the right operand
  • if it is a graph and if the right operand is a node, at returns the in and out edges corresponding to that node
  • if it is a graph and if the right operand is an edge, at returns the pair node_out::node_in of the edge
  • if it is a graph and if the right operand is a pair node1::node2, at returns the edge from node1 to node2 in the graph
  • if it is a list or a matrix, at returns the element at the index specified by the right operand
int var1 <- [1, 2, 3] at 2; // var1 equals 3 
point var2 <- [{1,2}, {3,4}, {5,6}] at 0; // var2 equals {1.0,2.0}

Examples:

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

See also: contains_all, contains_any,


at_distance

Possible uses:

  • container<unknown,geometry> at_distance float ---> list<geometry>
  • at_distance (container<unknown,geometry> , float) ---> list<geometry>

Result:

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

Examples:

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

See also: neighbors_at, neighbors_of, agent_closest_to, agents_inside, closest_to, inside, overlapping,


at_location

Possible uses:

  • geometry at_location point ---> geometry
  • at_location (geometry , point) ---> geometry

Result:

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

Examples:

geometry var0 <- self at_location {10, 20}; // var0 equals the geometry resulting from a translation to the location {10, 20} of the left-hand geometry (or agent). 
float var1 <- (box({10, 10 , 5}) at_location point(50,50,0)).location.x; // var1 equals 50.0

atan

Possible uses:

  • atan (float) ---> float
  • atan (int) ---> float

Result:

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

Examples:

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

See also: acos, asin, tan,


atan2

Possible uses:

  • float atan2 float ---> float
  • atan2 (float , float) ---> float

Result:

the atan2 value of the two operands.

Comment:

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

Examples:

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

See also: atan, acos, asin,


attributes

Possible uses:

  • attributes (any) ---> attributes

Result:

casts the operand in a attributes object.


auto_correlation

Possible uses:

  • container auto_correlation int ---> float
  • auto_correlation (container , int) ---> float

Result:

Returns the auto-correlation of a data sequence given some lag

Examples:

float var0 <- auto_correlation([1,0,1,0,1,0],2); // var0 equals 1 
float var1 <- auto_correlation([1,0,1,0,1,0],1); // var1 equals -1