Numbers
Each time you write a number, for example 9, -10, or 3,12, behind the screen, Xoscript will convert these numbers into a Number object. You can send messages to this Number object, or you could assign the number to a variable and send messages afterwards:
10 even?
>> tenner := 10.
tenner even?
Both notations are valid. The Number object responds to the following messages…
Most of these messages are self-explanatory and allow you to execute mathematical operations or comparisons.
Note that you may use ≤ ≥ ≠ × and ÷ instead their ASCII counterparts. This is a matter of preference.
The difference between binary mathematical messages (+) and their keyword variations (add:) is that the former will return a new number, which is the result of the operation, whereas with the latter the object itself will be modified. This is illustrated in the following example:
Example:
>> a := 1.
>> b := a + 3.
a add: 2.
Out write: a, stop.
Out write: b, stop.
Result:
In the above example, b = 4 and a = 3. With add: 2 the value of a is raised by 2, while + 3 creates a new number that is equal to a + 3. The same applies to other mathematical processes, e.g., multiplications. By using the multiplication symbol, you will receive a new object as answer. In case you use the message multiply-by:, you will multiply the number itself.
With the message between:and:, for example in: Number between: X and: Y, you will get a number between X and Y. In this way, any random number can be generated:
>> a := Number between: 1 and: 10.
Out write: a, stop.
As of version 1.4, the build-in generator of random numbers in xoscript is crypogrpahically secure to the best of our knowledge.
You can attach a qualifier to a number, for instance, 6 apples. Each message that does not get recognised by a number will be considered a qualifier. You can retrieve the qualifier of a number by means of the message qualifier:
A qualifier is basically a Text object that is stored with the Number object. The qualifier is also printed after the number on a write: assignment. Qualifiers could be used to add amounts in mixed currencies for example. On adding the amounts, you can ask for the qualifiers. The following program example illustrates this principle by using a historical currency calculator (as the exchange rate remains reasonably stable!).
Example:
Number learn: ['plus:'] means: ['+'].
Number on: ['+'] do: { :x
>> rate := 1.
>> currency := x qualifier.
(currency = ['euros']) true: {
rate := 2.
}. <- (self plus: (x × rate)).
}.
>> dollars := 3.
>> euros := 2.
dollars qualify: ['dollars'].
euros qualify: ['euros'].
>> money := dollars + euros.
Out write: money, stop.
Result:
[ Number ] > [ Number ]
Example:
Out write: 8 > 7, stop.
Out write: 7 > 8, stop.
Result:
[ Number ] >=: [ Number ]
Example:
>> x := ( 8 >=: 7 ).
Out write: x, stop.
Result:
[ Number ] < [ Number ]
Example:
>> x := 8 < 7.
>> y := 7 < 8.
Out write: x, stop.
Out write: y, stop.
Result:
[ Number ] <=: [ Number ]
Example:
>> x := ( 8 <=: 7 ).
>> y := 7 ≤ 8.
Out write: x, stop.
Out write: y, stop.
Result:
[ Number ] = [ Number ]
Example:
>> x := 8 = 8.
>> y := 8 = 9.
Out write: x, stop.
Out write: y, stop.
Result:
[ Number ] !=: [ Number ]
Example:
>> x := ( 8 !=: 8 ).
>> y := 8 ≠ 9.
Out write: x, stop.
Out write: y, stop.
Result:
[ Number ] between: [ Number ] and: [ Number ]
Example:
>> x := Number between: 0 and: 10.
Out write: ((x >=: 0) and: (x <=: 10)), stop.
Result:
[ Number ] odd?
Example:
Out write: 2 odd?, stop.
Out write: 3 odd?, stop.
Result:
[ Number ] even?
Example:
Out write: 2 even?, stop.
Out write: 3 even?, stop.
Result:
[ Number ] + [ Number ]
Example:
>> x := 2 + 2.
>> y := x + 0.5.
Out write: x, stop.
Out write: y, stop.
Result:
[ Number ] add: [ Number ]
Example:
>> x := 1.
x add: 2.
Out write: x, stop.
Result:
[ Number ] - [ Number ]
Example:
>> x := 9.
>> y := x - 4.
Out write: y, stop.
Result:
[ Number ] subtract: [ Number ]
Example:
>> x := 3.
x subtract: 1.
Out write: x, stop.
Result:
[ Number ] * [ Number ]
Example:
>> x := 3 * 3.
Out write: x, stop.
Result:
[ Number ] multiply by: [ Number ]
Example:
>> x := 5.
x multiply-by: 2.
Out write: x, stop.
Result:
[ Number ] / [ Number ]
Example:
Out write: 10 / 2, stop.
Result:
[ Number ] divide by: [ Number ]
Example:
>> x := 10.
x divide-by: 2.
Out write: x, stop.
Result:
[ Number ] modulo: [ modulo ]
Example:
>> x := 11 modulo: 3.
Out write: x, stop.
Result:
[ Number ] power: [ Number ]
Example:
Out write: (2 power: 3).
Result:
[ Number ] positive?
Example:
{ :i
Out write: ( i - 5 ) positive?, stop.
} × 10.
Result:
[ Number ] negative?
Example:
{ :i
Out write: ( i - 5 ) negative?, stop.
} × 10.
Result:
[ Number ] floor
Example:
>> x := 4.5.
Out write: x floor, stop.
Result:
[ Number ] [ String ]
Example:
>> x := 3 dollars.
Out write: x qualifier.
Result:
[ Number ] qualifier.
Example:
>> x := 3 dollars.
Out write: x qualifier.
Result:
[ Number ] ceil
Example:
>> x := 4.5.
Out write: x ceil, stop.
Result:
[ Number ] round
Example:
>> x := 5.5.
Out write: x round, stop.
Result:
[ Number ] absolute
Example:
>> x := -7.
Out write: x absolute, stop.
Result:
[ Number ] square root
Example:
>> x := 49.
>> y := x sqrt.
Out write: y, stop.
Result:
[ Number ] sin
Example:
Out write: 123 sin, stop.
Result:
[ Number ] cos
Example:
Out write: 123 cos, stop.
Result:
[ Number ] tan
Example:
Out write: 123 tan, stop.
Result:
[ Number ] atan
Example:
Out write: 123 atan, stop.
Result:
[ Number ] log
Example:
Out write: 123 log, stop.
Result:
[ Number ] & [ Number ]
Example:
Out write: (8 & 10), stop.
Result:
[ Number ] | [ Number ]
Example:
Out write: (8 | 10), stop.
Result:
[ Number ] ^ [ Number ]
Example:
Out write: (8 ^ 10), stop.
Result:
[ Number ] string
Example:
>> x := 123.
Out write: x, stop.
>> x := 1.23.
Out write: x, stop.
>> x := 1,000,000.
Out write: x, stop.
Result:
[ Number ] raw
Example:
>> x := 123.
Out write: x plain, stop.
>> x := 1.23.
Out write: x plain, stop.
>> x := 1,000,000.
Out write: x plain, stop.
Result:
[ Number ] boolean
Example:
{ :i
Out write: (i - 1) bool, stop.
} × 10.
Result:
[ Int64 ] from-string: [ String ]
Example:
# create a 64-bit integer for exact calculations
>> a := Int64 from-string: ['123'].
# to string
Out write: a, stop.
# divide
Out write: a / (Int64 from-string: ['3']), stop.
# multiply
Out write: a * (Int64 from-string: ['2']), stop.
# add
Out write: a + (Int64 from-string: ['1']), stop.
# subtract
Out write: a - (Int64 from-string: ['2']), stop.
# compare
Out write: ( a = (Int64 from-string: ['123'])), stop.
Out write: ( a !=: (Int64 from-string: ['124'])), stop.
Out write: ( a < (Int64 from-string: ['124'])), stop.
Out write: ( a > (Int64 from-string: ['122'])), stop.
Out write: ( a >=: (Int64 from-string: ['123'])), stop.
Out write: ( a <=: (Int64 from-string: ['123'])), stop.
Result: