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
andor
(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_agent, get_belief_op, get_belief_with_name_op, get_beliefs_op, get_beliefs_with_name_op, get_current_intention_op, get_desire_op, get_desire_with_name_op, get_desires_op, get_desires_with_name_op, get_ideal_op, get_ideal_with_name_op, get_ideals_op, get_ideals_with_name_op, get_intention_op, get_intention_with_name_op, get_intentions_op, get_intentions_with_name_op, get_obligation_op, get_obligation_with_name_op, get_obligations_op, get_obligations_with_name_op, get_plan_name, get_uncertainties_op, get_uncertainties_with_name_op, get_uncertainty_op, get_uncertainty_with_name_op, 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_lifetime, set_modality, set_predicate, set_strength, with_about, with_agent, with_agent_cause, with_decay, with_dominance, with_familiarity, with_intensity, with_liking, with_solidarity, with_trust, with_truth, with_values,
Casting operators​
as, as_int, as_matrix, deserialize, field_with, font, from_gaml, from_json, is, is_skill, list_with, matrix_with, serialize, species_of, to_gaml, to_geojson, to_json, to_list, with_size, with_style,
Color-related operators​
-, /, *, +, blend, brewer_colors, brewer_palettes, gradient, grayscale, hsb, mean, median, palette, rgb, rnd_color, scale, sum, to_hsb,
Comparison operators​
Containers-related operators​
-, ::, +, 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,
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​
edge​
EDP-related operators​
Files-related operators​
agent_file, copy_file, crs, csv_file, delete_file, directory, dxf_file, evaluate_sub_model, file_exists, flush_all_files, 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_agent, 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_shape, is_simulation, is_svg, is_text, is_threeds, is_xml, json_file, new_folder, obj_file, osm_file, pgm_file, property_file, read, rename_file, shape_file, simulation_file, step_sub_model, svg_file, text_file, threeds_file, to_absolute_path, unzip, writable, xml_file, zip,
GamaMetaType​
GamaSVGFile​
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, 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,
Grid-related operators​
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,
ImageOperators​
*, antialiased, blend, blurred, brighter, clipped_with, darker, grayscale, horizontal_flip, image, matrix, rotated_by, send_image_to_websocket, sharpened, snapshot, tinted_with, vertical_flip, with_height, with_size, with_width,
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,
List-related operators​
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,
Map-related operators​
as_map, create_map, index_of, last_index_of,
Matrix-related operators​
-, /, ., *, +, append_horizontally, append_vertically, column_at, columns_list, determinant, eigenvalues, flatten, 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,
Pedestrian​
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, exp_density, exp_rnd, 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,
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, 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, k_nearest_neighbors, 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, touching, towards, transformed_by, translated_by, triangle, triangulate, union, using, voronoi, with_precision, without_holes,
Spatial properties operators​
covers, crosses, intersects, partially_overlaps,
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, k_nearest_neighbors, 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, 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, k_nearest_neighbors, kmeans, kurtosis, log_gamma, max, mean, mean_deviation, median, min, moment, moran, morrisAnalysis, mul, normal_area, normal_density, normal_inverse, predict, pValue_for_fStat, pValue_for_tStat, quantile, quantile_inverse, rank_interpolated, residuals, rms, rSquare, simple_clustering_by_distance, skewness, sobolAnalysis, split, split_in, split_using, standard_deviation, student_area, student_t_inverse, sum, t_test, variance,
Strings-related operators​
+, <, <=, >, >=, at, capitalize, char, compress, concatenate, 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, uncompress, upper_case,
SubModel​
System​
., choose, command, copy, copy_from_clipboard, copy_to_clipboard, copy_to_clipboard, dead, enter, every, from_gaml, is_error, is_reachable, is_warning, play_sound, user_confirm, user_input_dialog, wizard, wizard_page,
Time-related operators​
Types-related operators​
action, agent, BDIPlan, bool, container, conversation, directory, emotion, file, float, gaml_type, geometry, graph, int, kml, list, map, matrix, mental_state, message, Norm, pair, path, point, predicate, regression, rgb, Sanction, skill, social_link, species, topology, unknown,
User control operators​
choose, enter, user_confirm, user_input_dialog, wizard, wizard_page,
Operators​
-
​
Possible uses:​
-
(float
) --->float
-
(point
) --->point
-
(int
) --->int
matrix<unknown>
-
float
--->matrix
-
(matrix<unknown>
,float
) --->matrix
point
-
float
--->point
-
(point
,float
) --->point
int
-
int
--->int
-
(int
,int
) --->int
geometry
-
container<unknown,geometry>
--->geometry
-
(geometry
,container<unknown,geometry>
) --->geometry
field
-
float
--->field
-
(field
,float
) --->field
geometry
-
float
--->geometry
-
(geometry
,float
) --->geometry
int
-
float
--->float
-
(int
,float
) --->float
field
-
int
--->field
-
(field
,int
) --->field
date
-
float
--->date
-
(date
,float
) --->date
list
-
unknown
--->list
-
(list
,unknown
) --->list
date
-
date
--->float
-
(date
,date
) --->float
field
-
matrix
--->field
-
(field
,matrix
) --->field
point
-
point
--->point
-
(point
,point
) --->point
float
-
int
--->float
-
(float
,int
) --->float
map
-
map
--->map
-
(map
,map
) --->map
rgb
-
int
--->rgb
-
(rgb
,int
) --->rgb
matrix<unknown>
-
matrix
--->matrix
-
(matrix<unknown>
,matrix
) --->matrix
container
-
container
--->list
-
(container
,container
) --->list
species
-
agent
--->list
-
(species
,agent
) --->list
geometry
-
geometry
--->geometry
-
(geometry
,geometry
) --->geometry
float
-
float
--->float
-
(float
,float
) --->float
rgb
-
rgb
--->rgb
-
(rgb
,rgb
) --->rgb
point
-
int
--->point
-
(point
,int
) --->point
int
-
matrix
--->matrix
-
(int
,matrix
) --->matrix
float
-
matrix
--->matrix
-
(float
,matrix
) --->matrix
date
-
int
--->date
-
(date
,int
) --->date
matrix<unknown>
-
int
--->matrix
-
(matrix<unknown>
,int
) --->matrix
map
-
pair
--->map
-
(map
,pair
) --->map
Result:​
If it is used as a unary operator, it returns the opposite of the operand. Returns the difference of the two operands.
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 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 var0 <- {1, 2} - 4.5; // var0 equals {-3.5, -2.5, -4.5}
point var1 <- {1, 2} - 4; // var1 equals {-3.0,-2.0,-4.0}
- if both operands are numbers, performs a normal arithmetic difference and returns a float if one of them is a float.
int var2 <- 1 - 1; // var2 equals 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 var3 <- rectangle(10,10) - [circle(2), square(2)]; // var3 equals rectangle(10,10) - (circle(2) + square(2))
- 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 var4 <- shape - 5; // var4 equals a geometry corresponding to the geometry of the agent applying the operator reduced by a distance of 5
- 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> var5 <- [1,2,3,4,5,6,2] - 2; // var5 equals [1,3,4,5,6,2]
list<int> var6 <- [1,2,3,4,5,6] - 0; // var6 equals [1,2,3,4,5,6]
- 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 var7 <- date('2000-01-02') - date('2000-01-01'); // var7 equals 86400
- if both operands are points, returns their difference (coordinates per coordinates).
point var8 <- {1, 2} - {4, 5}; // var8 equals {-3.0, -3.0}
- 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 var9 <- rgb([255, 128, 32]) - 3; // var9 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> var10 <- [1,2,3,4,5,6] - [2,4,9]; // var10 equals [1,3,5,6]
list<int> var11 <- [1,2,3,4,5,6] - [0,8]; // var11 equals [1,2,3,4,5,6]
- if both operands are a point, a geometry or an agent, returns the geometry resulting from the difference between both geometries
geometry var12 <- geom1 - geom2; // var12 equals a geometry corresponding to difference between geom1 and geom2
- if both operands are colors, returns a new color resulting from the subtraction of the two operands, component by component
rgb var13 <- rgb([255, 128, 32]) - rgb('red'); // var13 equals rgb([0,128,32])
- if one operand is a matrix and the other a number (float or int), performs a normal arithmetic difference of the number with each element of the matrix (results are float if the number is a float.
matrix var14 <- 3.5 - matrix([[2,5],[3,4]]); // var14 equals matrix([[1.5,-1.5],[0.5,-0.5]])
- 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 var15 <- date('2000-01-01') - 86400; // var15 equals date('1999-12-31')
Examples:​
float var16 <- 1 - 1.0; // var16 equals 0.0
float var17 <- 3 - 1.2; // var17 equals 1.8
date var18 <- date('2000-01-01') - 86400; // var18 equals date('1999-12-31')
float var19 <- 1.0 - 1; // var19 equals 0.0
float var20 <- 3.7 - 1; // var20 equals 2.7
float var21 <- 3.0 - 1; // var21 equals 2.0
map var22 <- ['a'::1,'b'::2] - ['b'::2]; // var22 equals ['a'::1]
map var23 <- ['a'::1,'b'::2] - ['b'::2,'c'::3]; // var23 equals ['a'::1]
point var24 <- -{3.0,5.0}; // var24 equals {-3.0,-5.0}
point var25 <- -{1.0,6.0,7.0}; // var25 equals {-1.0,-6.0,-7.0}
float var26 <- 1.0 - 1.0; // var26 equals 0.0
float var27 <- 3.7 - 1.2; // var27 equals 2.5
float var28 <- 3.0 - 1.2; // var28 equals 1.8
point var29 <- {2.0,3.0,4.0} - 1; // var29 equals {1.0,2.0,3.0}
matrix var30 <- (10.0 - (3.0 as_matrix({2,3}))); // var30 equals matrix([[7.0,7.0,7.0],[7.0,7.0,7.0]])
int var31 <- - (-56); // var31 equals 56
map var32 <- ['a'::1,'b'::2] - ('b'::2); // var32 equals ['a'::1]
map var33 <- ['a'::1,'b'::2] - ('c'::3); // var33 equals ['a'::1,'b'::2]
See also: +, *, /, milliseconds_between, -, inter,
:
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
!=
​
Possible uses:​
float
!=
float
--->bool
!=
(float
,float
) --->bool
float
!=
int
--->bool
!=
(float
,int
) --->bool
int
!=
int
--->bool
!=
(int
,int
) --->bool
int
!=
float
--->bool
!=
(int
,float
) --->bool
date
!=
date
--->bool
!=
(date
,date
) --->bool
unknown
!=
unknown
--->bool
!=
(unknown
,unknown
) --->bool
Result:​
true if both operands are different, false otherwise true if both operands are different, false otherwise
Examples:​
bool var0 <- 3.0 != 3.0; // var0 equals false
bool var1 <- 4.0 != 4.7; // var1 equals true
bool var2 <- 3.0 != 3; // var2 equals false
bool var3 <- 4.7 != 4; // var3 equals true
bool var4 <- 3 != 3; // var4 equals false
bool var5 <- 4 != 5; // var5 equals true
bool var6 <- 3 != 3.0; // var6 equals false
bool var7 <- 4 != 4.7; // var7 equals true
bool var8 <- #now != #now minus_hours 1; // var8 equals true
bool var9 <- [2,3] != [2,3]; // var9 equals false
bool var10 <- [2,4] != [2,3]; // var10 equals true
?
​
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
point
/
int
--->point
/
(point
,int
) --->point
matrix<unknown>
/
matrix
--->matrix
/
(matrix<unknown>
,matrix
) --->matrix
rgb
/
float
--->rgb
/
(rgb
,float
) --->rgb
float
/
int
--->float
/
(float
,int
) --->float
int
/
int
--->float
/
(int
,int
) --->float
float
/
float
--->float
/
(float
,float
) --->float
matrix<unknown>
/
float
--->matrix
/
(matrix<unknown>
,float
) --->matrix
matrix<unknown>
/
int
--->matrix
/
(matrix<unknown>
,int
) --->matrix
int
/
float
--->float
/
(int
,float
) --->float
field
/
int
--->field
/
(field
,int
) --->field
point
/
float
--->point
/
(point
,float
) --->point
field
/
float
--->field
/
(field
,float
) --->field
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 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 var1 <- rgb([255, 128, 32]) / 2.5; // var1 equals rgb([102,51,13])
- if both operands are numbers (float or int), performs a normal arithmetic division and returns a float.
float var2 <- 3 / 5.0; // var2 equals 0.6
- if the left operand is a point, returns a new point with coordinates divided by the right operand
point var3 <- {5, 7.5} / 2.5; // var3 equals {2, 3}
point var4 <- {2,5} / 4; // var4 equals {0.5,1.25}
.
​
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
^
float
--->float
^
(int
,float
) --->float
int
^
int
--->float
^
(int
,int
) --->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
@
​
Same signification as at
*
​
Possible uses:​
matrix<unknown>
*
int
--->matrix
*
(matrix<unknown>
,int
) --->matrix
float
*
float
--->float
*
(float
,float
) --->float
point
*
point
--->float
*
(point
,point
) --->float
point
*
int
--->point
*
(point
,int
) --->point
float
*
matrix
--->matrix
*
(float
,matrix
) --->matrix
int
*
float
--->float
*
(int
,float
) --->float
point
*
float
--->point
*
(point
,float
) --->point
rgb
*
float
--->rgb
*
(rgb
,float
) --->rgb
matrix<unknown>
*
float
--->matrix
*
(matrix<unknown>
,float
) --->matrix
float
*
int
--->float
*
(float
,int
) --->float
geometry
*
float
--->geometry
*
(geometry
,float
) --->geometry
field
*
int
--->field
*
(field
,int
) --->field
field
*
float
--->field
*
(field
,float
) --->field
rgb
*
int
--->rgb
*
(rgb
,int
) --->rgb
matrix<unknown>
*
matrix
--->matrix
*
(matrix<unknown>
,matrix
) --->matrix
geometry
*
point
--->geometry
*
(geometry
,point
) --->geometry
int
*
matrix
--->matrix
*
(int
,matrix
) --->matrix
int
*
int
--->int
*
(int
,int
) --->int
Result:​
Returns the product of the two operands.
Special cases:​
- if both operands are points, returns their scalar product
float var1 <- {2,5} * {4.5, 5}; // var1 equals 34.0
- if the left-hand operator is a point and the right-hand a number, returns a point with coordinates multiplied by the number
point var2 <- {2,5} * 4; // var2 equals {8.0, 20.0}
point var3 <- {2, 4} * 2.5; // var3 equals {5.0, 10.0}
- 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 var4 <- rgb([255, 128, 32]) * 2.0; // var4 equals rgb([255,255,64])
- if the left-hand operand is a geometry and the right-hand operand a float, returns a geometry corresponding to the left-hand operand (geometry, agent, point) scaled by the right-hand operand coefficient
geometry var5 <- circle(10) * 2; // var5 equals circle(20)
geometry var6 <- (circle(10) * 2).location with_precision 9; // var6 equals (circle(20)).location with_precision 9
float var7 <- (circle(10) * 2).height with_precision 9; // var7 equals (circle(20)).height with_precision 9
- 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 var8 <- rgb([255, 128, 32]) * 2; // var8 equals rgb([255,255,64])
- 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 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 var10 <- 2 * matrix([[2,5],[3,4]]); // var10 equals matrix([[4,10],[6,8]])
- 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 var11 <- 1 * 1; // var11 equals 1
Examples:​
float var0 <- 2.5 * 2; // var0 equals 5.0
*
​
Possible uses:​
image
*
float
--->image
*
(image
,float
) --->image