Operators

{text
    3 + 4 * 5 = {value 3 + 4 * 5}

    (3 + 4) * 5 = {value (3 + 4) * 5}
}

{value
    || Declare an integer "x" and initialize it to 28
    let x:int = 28
    || Declare a double "y" and initialize it to 3.0
    let y:double = 3.0
    || Declare an int "z" and initialize it to 3
    let z:int = 3

    {text
        || Output the value of "x / y" and then output the
        || data type of the result.
        || According to the rules, the result should be a
        || double (or a quantity)
        x / y is ... {value x / y}, which is a {type-of x / y}
        || Output the value of "x / z" and then output the
        || data type of the result.
        x div z is ... {value x div z}, which is a {type-of x div z}
    }
}

{text 3 / 2 is...}     {value 3 / 2}
{br}{text 3.0 / 2 is...}   {value 3.0 / 2}
{br}{text 3s / 2s is...}    {value 3s / 2s}
{br}{text 3s / 2 is...}    {value 3s / 2}

{text 3 div 2 is...}   {value 3 div 2}
{br}{text 3.0 div 2 is...} {value 3.0 div 2}
{br}{text 3s div 2s is...}  {value 3s div 2s}
|| Note that you cannot use div to divide
|| 3 seconds by 2.  You can use only the /
|| operator in this case.

{text 3 rem 2 is...}   {value 3 rem 2}
{br}{text -3 rem 2 is...}  {value -3 rem 2}
{br}{text 3 rem -2 is...}  {value 3 rem -2}
{br}{text -3 rem -2 is...} {value -3 rem -2}

{text 3 mod 2 is...}   {value 3 mod 2}
{br}{text -3 mod 2 is...}  {value -3 mod 2}
{br}{text 3 mod -2 is...}  {value 3 mod -2}
{br}{text -3 mod -2 is...} {value -3 mod -2}

{value
    || Declare and initialize two variables "a"
    || and "b"
    let a:int = 5
    let b:int = 6

    || Use each relational operator, in turn to
    || compare "a" and "b"
    {text a is {value a}, b is {value b}
        {br}a == b is ... {value a == b}
        {br}a != b is ... {value a != b}
        {br}a > b is ... {value a > b}
        {br}a < b is ... {value a < b}
        {br}a >= b is ... {value a >= b}
        {br}a <= b is ... {value a <= b}
    }
}

{value
    || Declare three floats "a", "b", and "c".
    || Initialize "a" to 1.0f.
    || Initialize "b" to .9999999f, which is within
    || the limit of the number of significant digits
    || for a float.
    || Initialize "c" to .99999999f, which is not
    || within the limit.
    || Declare and initialize a VBox called "message"
    || which will contain the output of this example.
    let a:float = 1.0f
    let b:float = 0.9999999f
    let c:float = 0.99999999f
    let message:VBox = {VBox}

    || Test whether "a" is equal to "b" and add the
    || appropriate text to "message"
    {message.add {paragraph Is 1.0f equal to 0.9999999f?}}
    {if a == b then
        {message.add {text Yes}}
     else
        {message.add {text No}}
    }

    || Test whether "a" is equal to "c" and add the
    || appropriate text to "message"
    {message.add {paragraph Is 1.0f equal to 0.99999999f?}}
    {if a == c then
        {message.add {text Yes}}
     else
        {message.add {text No}}
    }

    || Return the value of "message"
    message
}

{let x:{Array-of int} = {new {Array-of int}, 1, 2, 3}}
{let y:{Array-of int} = {new {Array-of int}, 1, 2, 3}}
{let z:{Array-of int} = x}

x == y is... {value x == y}

x == z is... {value x == z}

{let x:String = {String "Hello"}}
{let y:String = {String "Hello"}}
{let z:String = x}

x == y is... {value x == y}

x == z is... {value x == z}

{value
    || Declare a variable to be an instance of
    || the HBox class, which inherits from Graphic
    let h:HBox = {HBox}

    {text h isa Graphic evaluates to ... {value h isa Graphic}{br}
          h isa HBox evaluates to ... {value h isa HBox}{br}
          h isa float evaluates to ... {value h isa float}
    }
}

{value
    || Declare an int
    let i:int

    {text i isa int evaluates to ... {value i isa int}
        {br}i isa bool evaluates to ... {value i isa bool}
        {br}i isa Graphic evaluates to ... {value i isa Graphic}
    }
}

{value
    || Declare and initialize two variables "a"
    || and "b"
    let a:bool=true
    let b:bool=false

    || Use the logical operators with "a" and "b"
    {text a is {value a}, b is {value b}
        {br}a and b is ... {value a and b}
        {br}a and true is ... {value a and true}
        {br}a and (5 > 2) is ... {value a and (5 > 2)}
        {br}a or b is ... {value a or b}
        {br}not a is ... {value not a}
        {br}not b is ... {value not b}
    }
}

{value
    || Declare and initialize an int, char, double,
    || bool, and String variable
    let i:int = 3
    let c:char = '='
    let d:double = 3.7
    let b:bool = false
    let s:String = "a horse"

    || Concatenate some strings
    let temp1:String = s & " is " & s & " ... "
    let temp2:String = i & c & d & " is " & b
    let result:String = temp1 & temp2

    || Return the "result" string
    result
}

{value
    || Declare a variable "d" with data type double and
    || initialize the variable with the value 37.7
    let d:double = 37.7

    || Display the value of the variable "d" converted
    || to an int.
    d asa int
}