You are currently not logged in! Enter your authentication credentials below to log in. You need to have cookies enabled to log in.
This shows you the differences between two versions of the page.
|
types:integer [2015-02-04 20:19 SLT] sei wording, more style changes |
types:integer [2015-09-22 17:39 SLT] (current) sei an -> a |
||
|---|---|---|---|
| Line 4: | Line 4: | ||
| The $ty[integer] type represents a number without decimals, as opposed to the $ty[float] type which can have decimals. | The $ty[integer] type represents a number without decimals, as opposed to the $ty[float] type which can have decimals. | ||
| - | Formally, the $ty[integer] type is a 32-bit signed integer, which means that its range is from -2147483648 to 2147483647. Integer constants are specified just by entering the digits. They can optionally be preceded with a minus sign for negative numbers, but rigorously speaking, the sign is not part of the number, but an operator, and thus it takes code space. There are two exceptions: if the number is immediately after a type cast prefix, or if it is in the globals initialization, the sign will be part of the number and not take code space. | + | Formally, the $ty[integer] type is a 32-bit signed integer, which means that its range is from -2147483648 to 2147483647. Integer literals are specified just by entering the digits. They can optionally be preceded with a minus sign for negative numbers, but rigorously speaking, the sign is not part of the number, but an operator, and thus it takes code space. There are two exceptions: if the number is immediately after a type cast prefix, or if it is in the globals initialization, the sign will be part of the number and not take code space. |
| If an integer literal is out of the range of a 32-bit unsigned integer, the result will automatically be -1; otherwise, the result will be the value taken as a signed 32-bit integer. For example: | If an integer literal is out of the range of a 32-bit unsigned integer, the result will automatically be -1; otherwise, the result will be the value taken as a signed 32-bit integer. For example: | ||
| Line 18: | Line 18: | ||
| Another way to specify an integer literal is in hexadecimal (also called base 16 or radix 16). The digits for hexadecimal are the normal digits from 0 to 9 plus the letters from A to F (case doesn't matter), making a total of 16 digits available (A is ten, B is eleven, and so on until F which is fifteen). In LSL, an hexadecimal number is entered by prefixing it with a zero and an ex; for example, ''0x12abcd34'' is an integer expressed in hexadecimal, equivalent to the decimal number 313249076. Since case doesn't matter, ''0X12AbCd34'' is the same number. | Another way to specify an integer literal is in hexadecimal (also called base 16 or radix 16). The digits for hexadecimal are the normal digits from 0 to 9 plus the letters from A to F (case doesn't matter), making a total of 16 digits available (A is ten, B is eleven, and so on until F which is fifteen). In LSL, an hexadecimal number is entered by prefixing it with a zero and an ex; for example, ''0x12abcd34'' is an integer expressed in hexadecimal, equivalent to the decimal number 313249076. Since case doesn't matter, ''0X12AbCd34'' is the same number. | ||
| - | Unlike other languages which inspired the syntax of LSL, LSL does not support octal (base 8) constants. | + | Unlike other languages which inspired the syntax of LSL, LSL does not support octal (base 8) literals. |
| === Type casting an integer to/from other types === | === Type casting an integer to/from other types === | ||
| Line 47: | Line 47: | ||
| === Examples === | === Examples === | ||
| - | == Examples of integer constants == | + | == Examples of integer literals == |
| - | * ''342'' is a constant representing the integer 342. | + | * ''342'' is a literal representing the integer 342. |
| - | * ''0x1'' is a constant representing the integer 1. | + | * ''0x1'' is a literal representing the integer 1. |
| - | * ''0XA'' is a constant representing the integer 10. | + | * ''0XA'' is a literal representing the integer 10. |
| - | * ''3.'' is not an integer constant; it is a $lty[float] constant. | + | * ''3.'' is not an integer literal; it is a $lty[float] literal. |
| == Examples of type conversion between string and integer == | == Examples of type conversion between string and integer == | ||
| Line 66: | Line 66: | ||
| * ''(integer)"0x3"'' gives the integer 3. | * ''(integer)"0x3"'' gives the integer 3. | ||
| * ''(integer)"0x2astuff"'' gives the integer 42 (0x2A in hexadecimal). | * ''(integer)"0x2astuff"'' gives the integer 42 (0x2A in hexadecimal). | ||
| - | * ''(integer)"0xcafeteria"'' gives the integer 51966 (0xCAFE in hexadecimal). The //t// is not an hexadecimal digit, so the parsing finishes there. However, //c//, //a//, //f// and //e// are valid hexadecimal digits | + | * ''(integer)"0xcafeteria"'' gives the integer 51966 (0xCAFE in hexadecimal). //c//, //a//, //f// and //e// are valid hexadecimal digits, but //t// is not, so the parsing finishes there. |
| === Operations on integers === | === Operations on integers === | ||
| Line 72: | Line 72: | ||
| Integers can be added ($op[+]), subtracted ($op[-]), multiplied ($op[`*]) and divided ($op[/]). When both sides of the operation are $ty[integer], the result is $ty[integer] too. Note that this is true in the case of division in particular, which means that the operation is //"integer division",// returning the quotient (thus rounding towards zero). For example, the result of ''7/2'' is the integer 3, because 7 divided by 2 gives a quotient of 3. When either side of the operation is a float and the other an integer, the integer will be converted to $ty[float] if it is not so already; for example, ''3.0+2'' is equivalent to ''3.0+(float)2'' and results in the float ''5.0'', and ''7/(float)2'' or ''(float)7/2'' both result in the float ''3.5''. Note, however, that ''(float)(7/2)'' results in the float ''3.0'', because first ''7/2'' is performed, which results in ''3'', and then the conversion of ''3'' to float occurs. | Integers can be added ($op[+]), subtracted ($op[-]), multiplied ($op[`*]) and divided ($op[/]). When both sides of the operation are $ty[integer], the result is $ty[integer] too. Note that this is true in the case of division in particular, which means that the operation is //"integer division",// returning the quotient (thus rounding towards zero). For example, the result of ''7/2'' is the integer 3, because 7 divided by 2 gives a quotient of 3. When either side of the operation is a float and the other an integer, the integer will be converted to $ty[float] if it is not so already; for example, ''3.0+2'' is equivalent to ''3.0+(float)2'' and results in the float ''5.0'', and ''7/(float)2'' or ''(float)7/2'' both result in the float ''3.5''. Note, however, that ''(float)(7/2)'' results in the float ''3.0'', because first ''7/2'' is performed, which results in ''3'', and then the conversion of ''3'' to float occurs. | ||
| - | Another operation available for integers (but not for floats) is called //modulo,// which means the remainder of the division. The sign used for modulo is the percent sign $op[%]. For example, the result of ''7%2'' is 1 because the remainder of dividing 7 by 2 is 1; ''51%15'' gives 6 because when dividing 51 by 15, the remainder is 6. | + | Another operation available for integers (but not for floats) is called //modulo,// which means the remainder of the division. The symbol used for modulo is the percent sign $op[%]. For example, the result of ''7%2'' is 1 because the remainder of dividing 7 by 2 is 1; ''51%15'' gives 6 because when dividing 51 by 15, the remainder is 6. |
| A minus sign can prefix any integer value, and the result is the value with the sign changed. Note that it's much preferable to write ''-var'' than ''var*-1'', as the former uses less code space and is faster. | A minus sign can prefix any integer value, and the result is the value with the sign changed. Note that it's much preferable to write ''-var'' than ''var*-1'', as the former uses less code space and is faster. | ||
| Line 78: | Line 78: | ||
| Integers can be compared for equality ($op[==]), inequality ($op[!=]), less than ($op[`<]), greater than ($op[>]), less or equal ($op[`<=]) and greater or equal ($op[>=]). All of the comparison operators can be applied to two integers, resulting in either the integer $lct[TRUE] (1) or the integer $lct[FALSE] (0), depending on the result of the comparison. All of these operators can also be applied to $ty[float] (if one of the arguments is an integer and the other is a float, the integer will be converted to $ty[float] before comparing), but the result of the comparison is still an integer, either 0 or 1. | Integers can be compared for equality ($op[==]), inequality ($op[!=]), less than ($op[`<]), greater than ($op[>]), less or equal ($op[`<=]) and greater or equal ($op[>=]). All of the comparison operators can be applied to two integers, resulting in either the integer $lct[TRUE] (1) or the integer $lct[FALSE] (0), depending on the result of the comparison. All of these operators can also be applied to $ty[float] (if one of the arguments is an integer and the other is a float, the integer will be converted to $ty[float] before comparing), but the result of the comparison is still an integer, either 0 or 1. | ||
| - | Integers are also used as boolean values (values that express a truth value of either //true// or //false,// sometimes also called flags). See $lty[Boolean] for details. There are three logical operations that operate on integers that are interpreted as boolean: the $op[&&] ("logical and") operator, the $op[||] ("logical or") operator and the $op[!] ("logical not") operator. | + | == Logical and bitwise operators == |
| + | |||
| + | Integers are also used as boolean values (values that express a truth value of either //true// or //false,// sometimes also called flags). See $lty[Boolean] for details. There are three logical operations that operate on integers that are interpreted as boolean: the $op[&&] ("logical and") operator, the $op[`|`|] ("logical or") operator and the $op[!] ("logical not") operator. | ||
| The //logical and// operator returns $lct[TRUE] when both elements evaluate to a truth value of //true// (which means they are distinct from 0), and to $lct[FALSE] otherwise. | The //logical and// operator returns $lct[TRUE] when both elements evaluate to a truth value of //true// (which means they are distinct from 0), and to $lct[FALSE] otherwise. | ||
| Line 114: | Line 116: | ||
| So the final result is the binary number 00000000000000000000000000000001 which is 1 in decimal. Similarly, ''5|3'' is 7 (00000000000000000000000000000111 in binary). //XOR// results in 1 when the bits are different, and 0 when they are equal (or put another way, it flips only the bits of the first operand which are 1's in the second operand); therefore ''5^3'' is 6 (00000000000000000000000000000110 in binary). | So the final result is the binary number 00000000000000000000000000000001 which is 1 in decimal. Similarly, ''5|3'' is 7 (00000000000000000000000000000111 in binary). //XOR// results in 1 when the bits are different, and 0 when they are equal (or put another way, it flips only the bits of the first operand which are 1's in the second operand); therefore ''5^3'' is 6 (00000000000000000000000000000110 in binary). | ||
| - | The //bitwise NOT// operator is an //unary// operator (one that applies to single numbers, like the minus sign in front of a number does). It uses the symbol $op[~] (tilde) and results in each bit of the number being flipped. For example, ''~5'' returns the binary number 11111111111111111111111111111010 which equals the decimal number -6. In arithmetic terms, ''~n'' performs the same operation as ''-1-n'', because ''-1'' is all ones in binary, and subtracting any binary number from it results in the bits of that number being flipped (e.g. in 4-bit arithmetic, 1111-1010 results in 0101). | + | The //bitwise NOT// operator is a //unary// operator (one that applies to single numbers, like the minus sign in front of a number does). It uses the symbol $op[~] (tilde) and results in each bit of the number being flipped. For example, ''~5'' returns the binary number 11111111111111111111111111111010 which equals the decimal number -6. In arithmetic terms, ''~n'' performs the same operation as ''-1-n'', because ''-1'' is all ones in binary, and subtracting any binary number from it results in the bits of that number being flipped (e.g. in 4-bit arithmetic, 1111-1010 results in 0101). |
| The operator $op[<<] takes two integers, and displaces the binary representation of the first number to the left by an amount of bits indicated by the second number, filling the digits inserted on the right with zeros, and making the higher-order bits to be lost. This effectively results in multiplying the first number by 2<sup>(second number)</sup>. For example, ''5<<3'' returns ''40'', because ''5<<3'' inserts three zeros on the right and discards the ones on the left, resulting in the binary number 00000000000000000000000000101000 which is 40 in decimal; or in other words, it multiplies 5 by 2³, i.e. returns 5 times 8 which is 40. | The operator $op[<<] takes two integers, and displaces the binary representation of the first number to the left by an amount of bits indicated by the second number, filling the digits inserted on the right with zeros, and making the higher-order bits to be lost. This effectively results in multiplying the first number by 2<sup>(second number)</sup>. For example, ''5<<3'' returns ''40'', because ''5<<3'' inserts three zeros on the right and discards the ones on the left, resulting in the binary number 00000000000000000000000000101000 which is 40 in decimal; or in other words, it multiplies 5 by 2³, i.e. returns 5 times 8 which is 40. | ||