Difference between revisions of "HashMap"

From Bohemia Interactive Community
Jump to navigation Jump to search
m (getOrDefault)
m (Some wiki formatting)
(31 intermediate revisions by 5 users not shown)
Line 1: Line 1:
{{SideTOC}}
+
{{TOC|side}}
A '''HashMap''' is a container storing Key-Value pairs which is very efficient with many entries that have different keys.<br>
+
{{GVI|arma3|2.02}}
Due to keys being stored by their hash, a HashMap provides constant-time lookup for keys, meaning its very efficient for finding a key. More information on wikipedia: https://en.wikipedia.org/wiki/Hash_table<br>
 
As a HashMap is a container, it stores some traits/properties with [[Array|Arrays]]
 
This container was added with v2.01 #TODO make a icon thingy or note thingy
 
  
See also: [[:Category:HashMap|HashMaps]]
 
  
== Working with Hash Maps ==
+
A '''HashMap''' is a specialized data structure that contains key-value pairs.<br>
 +
HashMaps provide (near) constant-time lookup for keys, making them highly efficient at finding the value associated with a specific key - even if there is a very large amount of keys.<br>
 +
See {{Wikipedia|Hash_table|Wikipedia}} to learn more about the underlying technology.
  
=== Array properties ===
+
While HashMaps and [[Array|Arrays]] share many traits (and [[SQF Syntax|SQF]] command names), there are important differences and HashMaps must not be considered as some sort of new or improved replacement for the Array.
  
A HashMap variable is a '''reference''' to the HashMap(see [https://en.wikipedia.org/wiki/Reference_(computer_science) Wikipedia reference page]);
 
this means that if the HashMap is edited, all the scripts/functions using a reference to this HashMap will see the edition.
 
  
[[private]] _myMap = [[createHashMapFromArray]] <nowiki>[["a",1], ["b",2], ["c",3]]</nowiki>;
+
== HashMap Basics ==
  [[private]] _myNewMap = _myMap;
+
 
  _myMap [[set]] ["z", 4];
+
This section introduces the HashMap and its features and is intended to help create a basic understanding of what HashMaps are and what they can be used for.
  _myNewMap [[get]] "z"; {{cc|will be 4}}
+
 
 +
=== Comparison with Arrays ===
 +
 
 +
The HashMap and the [[Array]] are both data structures that are used to store multiple elements. Arrays are simple and only store single elements, one after the other, while HashMaps store key-value pairs, where each key uniquely identifies a single value.
 +
 
 +
Unlike Arrays, HashMaps have no order, i.e. there is no such thing as a first, second, third or last element in a HashMap. As such, the [[a_hash_b|#]] and [[select]] commands can not be used with HashMaps. This also means that the order in which the [[forEach]]-loop processes a HashMap's key-value pairs is not deterministic.
 +
 
 +
Iterating over all elements in a HashMap is less efficient than doing the same in an Array.
 +
 
 +
=== Constant-time Key Lookup ===
 +
 
 +
HashMaps are specifically designed for (near) constant-time lookup of keys.
 +
 
 +
Consider the following example to understand what that means: Let's say we have an Array that looks like this ...
 +
_playerDataArray <nowiki>= [</nowiki>["Player_A_UID", "Data A-1", "Data A-2", ...], ["Player_B_UID", "Data B-1", "Data B-2", ...], ["Player_C_UID", "Data C-1", "Data C-2", ...], ...];
 +
... and we want to find a specific [[getPlayerUID|UID]] so that we can retrieve the corresponding data. We can easily achieve that using the [[findIf]] command:
 +
  _index = _playerDataArray [[findIf]] {[[Magic Variables#x|_x]] [[a_hash_b|#]] 0 [[isEqualTo]] "Wanted_UID"};
 +
_data = _playerDataArray [[a_hash_b|#]] _index;
 +
But what [[findIf]] actually does for us is something like this:
 +
  {
 +
[[if]] ([[Magic Variables#x|_x]] [[a_hash_b|#]] 0 [[isEqualTo]] "Wanted_UID") [[then]]
 +
{
 +
[[breakWith]] [[Magic Variables#forEachIndex|_forEachIndex]];
 +
};
 +
} [[forEach]] _playerDataArray;
 +
Now consider how many [[isEqualTo]] comparisons this [[forEach]]-loop has to perform: If the element identified by "Wanted_UID" is stored at or near the end of {{ic|_playerDataArray}}, then our code has to go through (almost) the entire Array to find it - and the same is the case if the element we are looking for does not exist in our Array.
 +
 
 +
Every single one of these comparisons takes some time - not much, but it will add up eventually. This is no problem as long as our Array is relatively small, but it becomes a serious issue when the Array starts growing: If there are 10,000 elements in the Array that means up to 10,000 comparisons might be necessary just to find a single element, if there are 100,000 elements that means up to 100,000 comparisons and so on - the amount of steps and time needed to find an element grows linearly with the Array size.<br>
 +
 
 +
And this is where HashMaps come in. Simply put: When a key-value pair is inserted into a HashMap, a hash function is applied to the key to determine the position at which the key-value pair is going to be stored. Then, when we want to retrieve the value associated with a specific key, the same hash function ({{arma3}} uses {{Wikipedia|Fowler%E2%80%93Noll%E2%80%93Vo_hash_function|FNV-1a 64-bit}}) is applied to that key and the resulting position tells the HashMap exactly where to find the key-value pair that we are looking for.
 +
  _data = _playerDataHashMap [[get]] "Wanted_UID";
 +
Since the process to find a given key-value pair is always the same (apply hash function, look at the resulting position, return the value that is stored there), it also always takes (more or less) the same amount of time - regardless of the size of the HashMap.
 +
 
 +
That is what constant-time lookup for keys means. And it comes with very useful benefits: The procedures to search for, retrieve, modify or remove a specific element can all be completed in constant time; whether the HashMap contains 10, 10,000 or 1,000,000 elements does not matter.
 +
 
 +
 
 +
== Working with HashMaps ==
 +
 
 +
=== Supported Key Types ===
 +
 
 +
Because of the requirement for the keys to be hashable (and constant), not all [[:Category: Data Types| Data Types]] can be used as keys.
 +
 
 +
Supported types are limited to:
 +
{{Columns|3|
 +
* [[Array]]
 +
* [[Boolean]]
 +
* [[Code]]
 +
* [[Config]]
 +
* [[Namespace]]
 +
* [[NaN]] <!-- TODO: What's up with this? -->
 +
* [[Number]]
 +
* [[Side]]
 +
* [[String]]
 +
}}
  
An array set through [[setVariable]] does not need to be assigned again if you modify it by reference:
+
{{Feature|important|
[[player]] [[setVariable]] ["myMap", [[createHashMapFromArray]] <nowiki>[["a",1], ["b",2], ["c",3]]</nowiki>];
+
* [[Array]] keys can only contain supported types.
[[private]] _myMap = [[player]] [[getVariable]] "myMap";
+
* [[Array]] keys are deep-copied on insertion and cannot be modified when retrieved via [[keys]] or inside [[forEach]].
_myMap [[set]] ["z", 4];
+
* The virtual type [[HashMapKey]] is a combination of all the supported types.}}
[[player]] [[getVariable]] "myMap"; {{cc|is [["a",1], ["b",2], ["c",3], ["z",4]]}}
 
  
 
=== Creating a HashMap ===
 
=== Creating a HashMap ===
  
  {{cc|Example of an empty HashMap}}
+
  {{cc|example of an empty HashMap:}}
 
  [[private]] _myMap = [[createHashMap]];
 
  [[private]] _myMap = [[createHashMap]];
  [[count]] _myMap; {{cc|returns 0}}
+
  [[count]] _myMap; {{cc|returns 0}}
 
   
 
   
  {{cc|Example of a prefilled HashMap}}
+
  {{cc|example of a prefilled HashMap:}}
  [[private]] _myFilledMap = [[createHashMapFromArray]] <nowiki>[["a",1], ["b",2], ["c", 3]]</nowiki>;
+
  [[private]] _myFilledMap = [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2], ["c", 3]];
  [[count]] _myFilledMap; {{cc|returns 2}}
+
  [[count]] _myFilledMap; {{cc|returns 3}}
  
 
=== Setting an element ===
 
=== Setting an element ===
  
 
  [[private]] _myMap = [[createHashMap]];
 
  [[private]] _myMap = [[createHashMap]];
  _myMap [[set]] [1, "hello there"]; {{cc|_myMap is [[1, "hello there"]]}}
+
  _myMap [[set]] [1, "hello there"]; {{cc|_myMap is [<nowiki/>[1, "hello there"]]}}
  
Inserting an element with a key that already exists inside the HashMap, will overwrite the existing key.
+
Inserting an element with a key that already exists inside the HashMap will overwrite the existing key.
 +
[[private]] _myMap = [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2]];
 +
_overwritten = _myMap [[set]] ["a", 1337]; {{cc|_myMap is now [<nowiki/>["a",1337], ["b",2]] and _overwritten is true}}
  
[[private]] _myMap = [[createHashMapFromArray]] <nowiki>[["a",1], ["b",2]]</nowiki>;
+
=== Getting an element ===
_overwritten = _myMap [[set]] ["a", 1337]; {{cc|_myMap is now [["a",1337], ["b",2]] and _overwritten is true}}
 
  
Keys inside the Hashmap need to be of a supported type, not all types are supported.
+
Values are retrieved by their key:
 +
[[private]] _myMap = [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2]];
 +
_myMap [[get]] "a"; {{cc|returns 1}}
 +
_myMap [[get]] "z"; {{cc|returns [[Nothing]]}}
 +
_myMap [[getOrDefault]] ["z", "NotFound"]; {{cc|returns "NotFound"}}
  
GameScalar | GameBool | GameString | GameArray | GameCode | GameSide | GameConfig | GameNamespace | GameNaN
+
=== Removing an element ===
#TODO
 
#TODO HashMapKey type
 
  
 +
Elements can be removed (deleted) from the HashMap using [[deleteAt]] with the element's key:
 +
[[private]] _myMap = [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2]];
 +
_myMap [[deleteAt]] "b"; {{cc|_myMap is [["a",1]]}}
  
=== Getting an element ===
+
=== Checking if an element exists ===
 
 
Values are retrieved by their key:
 
  
  [[private]] _myMap = [[createHashMapFromArray]] <nowiki>[["a",1], ["b",2]]</nowiki>;
+
It is possible to check if a key is present in the HashMap using the [[in]] command:
  _myMap [[get]] "a"; {{cc|returns 1}}
+
  [[private]] _myMap = [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2]];
_myMap [[get]] "z"; {{cc|returns [[Nothing]]}}
+
  "a" [[in]] _myMap; {{cc|returns [[true]]}}
  _myMap [[getOrDefault]] ["z", "NotFound"]; {{cc|returns "NotFound"}}
+
  "z" [[in]] _myMap; {{cc|returns [[false]]}}
  
 
=== Counting elements ===
 
=== Counting elements ===
The [[count]] command can be used to return the number of Key-Value Pairs stored in the HashMap:
 
  
  [[private]] _myMap = [[createHashMapFromArray]] <nowiki>[["a",1], ["b",2]]</nowiki>;
+
The [[count]] command can be used to return the number of key-value pairs stored in the HashMap:
 +
  [[private]] _myMap = [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2]];
 
  [[count]] _myMap ; {{cc|returns 2}}
 
  [[count]] _myMap ; {{cc|returns 2}}
  
=== HashMap Copy ===
+
=== Retrieving keys ===
  
  [[private]] _myMap = [[createHashMapFromArray]] <nowiki>[["a",1], ["b",2]]</nowiki>;
+
Retrieving an [[Array]] of all keys in the HashMap using the [[keys]] command:
 +
  [[private]] _myMap = [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2]];
 +
[[keys]] _myMap; {{cc|returns ["a", "b"]}}
 +
 
 +
=== HashMap variables ===
 +
 
 +
A HashMap variable is a reference to the HashMap (see {{Wikipedia|Reference_(computer_science)|Wikipedia}}); this means that if the HashMap is edited, all scripts and functions using this HashMap will see the changes.
 +
[[private]] _myMap = [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2], ["c",3]];
 +
[[private]] _myNewMap = _myMap;
 +
_myMap [[set]] ["z", 4];
 +
_myNewMap [[get]] "z"; {{cc|returns 4}}
 +
 
 +
A HashMap set through [[setVariable]] does not need to be assigned again:
 +
[[player]] [[setVariable]] ["myMap", [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2], ["c",3]]];
 +
[[private]] _myMap = [[player]] [[getVariable]] "myMap";
 +
_myMap [[set]] ["z", 4];
 +
[[player]] [[getVariable]] "myMap"; {{cc|returns [<nowiki/>["a",1], ["b",2], ["c",3], ["z",4]]}}
 +
 
 +
=== Copying a HashMap ===
 +
 
 +
[[private]] _myMap = [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2]];
 
  [[private]] _myNewMap = _myMap;
 
  [[private]] _myNewMap = _myMap;
 
  _myMap [[set]] ["a", 1337];
 
  _myMap [[set]] ["a", 1337];
  _myNewMap [[get]] "a"; {{cc|will be 1337}}
+
  _myNewMap [[get]] "a"; {{cc|returns 1337}}
  
 
In order to avoid this behaviour, '''copy''' the HashMap with [[+|+ (plus)]]:
 
In order to avoid this behaviour, '''copy''' the HashMap with [[+|+ (plus)]]:
 
+
  [[private]] _myMap = [[createHashMapFromArray]] [<nowiki/>["a",1], ["b",2]];
{{cc|making copy}}
 
  [[private]] _myMap = [[createHashMapFromArray]] <nowiki>[["a",1], ["b",2]]</nowiki>;
 
 
  [[private]] _myNewMap = [[+]]_myMap;
 
  [[private]] _myNewMap = [[+]]_myMap;
 
  _myMap [[set]] ["a", 1337];
 
  _myMap [[set]] ["a", 1337];
 
  _myNewMap [[get]] "a"; {{cc|still 1}}
 
  _myNewMap [[get]] "a"; {{cc|still 1}}
  
[[Array|Arrays]] stored as Key or value in the HashMap will also be deep-copied.
+
[[Array]]s stored as key or value in the HashMap will also be deep-copied.
 
 
=== Removing (deleting) elements ===
 
  
You can remove elements from the HashMap by using [[deleteAt]] with the elements key:
 
  
[[private]] _myMap = [[createHashMapFromArray]] <nowiki>[["a",1], ["b",2]]</nowiki>;
+
== Advanced Usage ==
_myMap [[deleteAt]] "b"; {{cc|_myMap is [["a",1]]}}
 
  
=== Iterating through the HashMap ===
+
=== Iterating through a HashMap ===
  
The simplest way to iterate through a HashMap is the [[forEach]] command:
+
In general, HashMaps have to be considered unordered. While iterating through them is possible with [[forEach]], it is less efficient than looping through [[Array|Arrays]].
 +
[[private]] _myMap = [[createHashMapFromArray]] [<nowiki/>["a", 1], ["b", 2]];
 +
{ [[systemChat]] [[str]] [<nowiki/>[[Magic Variables#x|_x]], [[_y]]] } [[forEach]] _myMap;
  
[[private]] _myMap = [[createHashMapFromArray]] <nowiki>[["a",1], ["b",2]]</nowiki>;
+
When iterating through a HashMap with [[forEach]], <tt>[[Magic Variables#x|_x]]</tt> contains the key of the current element and <tt>[[_y]]</tt> contains the corresponding value.
{ [[systemChat]] [[str]] [ [[_x]], _y ] } [[forEach]] _myMap;
 
  
When iterating through a HashMap with forEach, the _x variable holds the key of the current element, while the _y variable holds its value.
+
=== Merging two HashMaps ===
  
== Advanced usage ==
+
Two HashMaps can be merged together using [[merge]].
 +
_hashMap1 [[merge]] _hashMap2;
  
  
== Common errors ==
+
== Common Errors ==
  
=== Scalar Key precision ===
+
=== Scalar Key Precision ===
  
bla bla when using scalar key bla bla link to wikipedia floating point precision
+
[[Number|Numbers]] in {{arma3}} are floating point numbers, and because there are gaps between floating point numbers, rounding is necessary - see also {{Wikipedia|Single-precision_floating-point_format|Wikipedia}}. For example, 87654316, 87654317, 87654318, 87654319, 87654320, 87654321, 87654322, 87654323 and 87654324 will all be rounded to and treated as the same value by the game engine (because the actual value of each of these numbers can not be represented as an {{arma3}} floating point number). Similar problems occur with fractional numbers:
 +
{{cc|this will return [[false]]:}}
 +
(0.3 [[+]] 0.4 [[==]] 0.7)
  
 +
This means that using very large numbers or fractional numbers as HashMap keys has to be done cautiously to avoid accidentally overwriting existing keys.
  
  
 
== See Also ==
 
== See Also ==
  
* [[:Category:HashMaps|HashMaps]]
+
* [[:Category:Command Group: HashMap|All HashMap commands]]  
 +
 
  
 
[[Category: Data Types]]
 
[[Category: Data Types]]
 +
[[Category:Introduced with Arma 3 version 2.02]]

Revision as of 17:47, 29 September 2021

Arma 3 logo black.png2.02


A HashMap is a specialized data structure that contains key-value pairs.
HashMaps provide (near) constant-time lookup for keys, making them highly efficient at finding the value associated with a specific key - even if there is a very large amount of keys.
See Wikipedia to learn more about the underlying technology.

While HashMaps and Arrays share many traits (and SQF command names), there are important differences and HashMaps must not be considered as some sort of new or improved replacement for the Array.


HashMap Basics

This section introduces the HashMap and its features and is intended to help create a basic understanding of what HashMaps are and what they can be used for.

Comparison with Arrays

The HashMap and the Array are both data structures that are used to store multiple elements. Arrays are simple and only store single elements, one after the other, while HashMaps store key-value pairs, where each key uniquely identifies a single value.

Unlike Arrays, HashMaps have no order, i.e. there is no such thing as a first, second, third or last element in a HashMap. As such, the # and select commands can not be used with HashMaps. This also means that the order in which the forEach-loop processes a HashMap's key-value pairs is not deterministic.

Iterating over all elements in a HashMap is less efficient than doing the same in an Array.

Constant-time Key Lookup

HashMaps are specifically designed for (near) constant-time lookup of keys.

Consider the following example to understand what that means: Let's say we have an Array that looks like this ...

_playerDataArray = [["Player_A_UID", "Data A-1", "Data A-2", ...], ["Player_B_UID", "Data B-1", "Data B-2", ...], ["Player_C_UID", "Data C-1", "Data C-2", ...], ...];

... and we want to find a specific UID so that we can retrieve the corresponding data. We can easily achieve that using the findIf command:

_index = _playerDataArray findIf {_x # 0 isEqualTo "Wanted_UID"};
_data = _playerDataArray # _index;

But what findIf actually does for us is something like this:

{
	if (_x # 0 isEqualTo "Wanted_UID") then
	{
		breakWith _forEachIndex;
	};
} forEach _playerDataArray;

Now consider how many isEqualTo comparisons this forEach-loop has to perform: If the element identified by "Wanted_UID" is stored at or near the end of _playerDataArray, then our code has to go through (almost) the entire Array to find it - and the same is the case if the element we are looking for does not exist in our Array.

Every single one of these comparisons takes some time - not much, but it will add up eventually. This is no problem as long as our Array is relatively small, but it becomes a serious issue when the Array starts growing: If there are 10,000 elements in the Array that means up to 10,000 comparisons might be necessary just to find a single element, if there are 100,000 elements that means up to 100,000 comparisons and so on - the amount of steps and time needed to find an element grows linearly with the Array size.

And this is where HashMaps come in. Simply put: When a key-value pair is inserted into a HashMap, a hash function is applied to the key to determine the position at which the key-value pair is going to be stored. Then, when we want to retrieve the value associated with a specific key, the same hash function (Arma 3 uses FNV-1a 64-bit) is applied to that key and the resulting position tells the HashMap exactly where to find the key-value pair that we are looking for.

_data = _playerDataHashMap get "Wanted_UID";

Since the process to find a given key-value pair is always the same (apply hash function, look at the resulting position, return the value that is stored there), it also always takes (more or less) the same amount of time - regardless of the size of the HashMap.

That is what constant-time lookup for keys means. And it comes with very useful benefits: The procedures to search for, retrieve, modify or remove a specific element can all be completed in constant time; whether the HashMap contains 10, 10,000 or 1,000,000 elements does not matter.


Working with HashMaps

Supported Key Types

Because of the requirement for the keys to be hashable (and constant), not all Data Types can be used as keys.

Supported types are limited to:

  • Array keys can only contain supported types.
  • Array keys are deep-copied on insertion and cannot be modified when retrieved via keys or inside forEach.
  • The virtual type HashMapKey is a combination of all the supported types.

Creating a HashMap

// example of an empty HashMap:
private _myMap = createHashMap;
count _myMap; // returns 0

// example of a prefilled HashMap:
private _myFilledMap = createHashMapFromArray [["a",1], ["b",2], ["c", 3]];
count _myFilledMap; // returns 3

Setting an element

private _myMap = createHashMap;
_myMap set [1, "hello there"]; // _myMap is [[1, "hello there"]]

Inserting an element with a key that already exists inside the HashMap will overwrite the existing key.

private _myMap = createHashMapFromArray [["a",1], ["b",2]];
_overwritten = _myMap set ["a", 1337]; // _myMap is now [["a",1337], ["b",2]] and _overwritten is true

Getting an element

Values are retrieved by their key:

private _myMap = createHashMapFromArray [["a",1], ["b",2]];
_myMap get "a"; // returns 1
_myMap get "z"; // returns Nothing
_myMap getOrDefault ["z", "NotFound"]; // returns "NotFound"

Removing an element

Elements can be removed (deleted) from the HashMap using deleteAt with the element's key:

private _myMap = createHashMapFromArray [["a",1], ["b",2]];
_myMap deleteAt "b"; // _myMap is "a",1

Checking if an element exists

It is possible to check if a key is present in the HashMap using the in command:

private _myMap = createHashMapFromArray [["a",1], ["b",2]];
"a" in _myMap; // returns true
"z" in _myMap; // returns false

Counting elements

The count command can be used to return the number of key-value pairs stored in the HashMap:

private _myMap = createHashMapFromArray [["a",1], ["b",2]];
count _myMap ; // returns 2

Retrieving keys

Retrieving an Array of all keys in the HashMap using the keys command:

private _myMap = createHashMapFromArray [["a",1], ["b",2]];
keys _myMap; // returns ["a", "b"]

HashMap variables

A HashMap variable is a reference to the HashMap (see Wikipedia); this means that if the HashMap is edited, all scripts and functions using this HashMap will see the changes.

private _myMap = createHashMapFromArray [["a",1], ["b",2], ["c",3]];
private _myNewMap = _myMap;
_myMap set ["z", 4];
_myNewMap get "z"; // returns 4

A HashMap set through setVariable does not need to be assigned again:

player setVariable ["myMap", createHashMapFromArray [["a",1], ["b",2], ["c",3]]];
private _myMap = player getVariable "myMap";
_myMap set ["z", 4];
player getVariable "myMap"; // returns [["a",1], ["b",2], ["c",3], ["z",4]]

Copying a HashMap

private _myMap = createHashMapFromArray [["a",1], ["b",2]];
private _myNewMap = _myMap;
_myMap set ["a", 1337];
_myNewMap get "a"; // returns 1337

In order to avoid this behaviour, copy the HashMap with + (plus):

private _myMap = createHashMapFromArray [["a",1], ["b",2]];
private _myNewMap = +_myMap;
_myMap set ["a", 1337];
_myNewMap get "a"; // still 1

Arrays stored as key or value in the HashMap will also be deep-copied.


Advanced Usage

Iterating through a HashMap

In general, HashMaps have to be considered unordered. While iterating through them is possible with forEach, it is less efficient than looping through Arrays.

private _myMap = createHashMapFromArray [["a", 1], ["b", 2]];
{ systemChat str [_x, _y] } forEach _myMap;

When iterating through a HashMap with forEach, _x contains the key of the current element and _y contains the corresponding value.

Merging two HashMaps

Two HashMaps can be merged together using merge.

_hashMap1 merge _hashMap2;


Common Errors

Scalar Key Precision

Numbers in Arma 3 are floating point numbers, and because there are gaps between floating point numbers, rounding is necessary - see also Wikipedia. For example, 87654316, 87654317, 87654318, 87654319, 87654320, 87654321, 87654322, 87654323 and 87654324 will all be rounded to and treated as the same value by the game engine (because the actual value of each of these numbers can not be represented as an Arma 3 floating point number). Similar problems occur with fractional numbers:

// this will return false:
(0.3 + 0.4 == 0.7)

This means that using very large numbers or fractional numbers as HashMap keys has to be done cautiously to avoid accidentally overwriting existing keys.


See Also