# SCI Programming Language/Primitive Procedures

Chapter: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | Index

Primitive Procedures
Author: Jeff Stephenson

## Primitive Procedures

### Arithmetic Primitives

In the following examples, e1, e2, etc. are arbitrary expressions. Brackets [...] indicate optional entries. Procedures evaluate their parameters from left to right.

`(+ e1 e2 [e3...])`

 evaluates to: e1 + e2 [+ e3...] example: `(+ 7 12 4)` evaluates to 23.

#### Multiplication

`(* e1 e2 [e3...])`

 evaluates to: e1 (*e2[*e3...] example: `(* 2 10 3)` evaluates to 60.

#### Subtraction

`(- e1 e2)`

 evaluates to: e1 - e2 example: `(- 20 11)` evaluates to 9.

#### Division

`(/ e1 e2)`

 e1 / e2 example: `(/ 24 6)` evaluates to 4.*

* Note: does this round when necessary (up, down)?

#### Remainder

`(mod e1 e2)`

 evaluates to: the remainder of e1 when divided by e2. example: `(mod 17 5)` evaluates to 2.

#### Operation Shift Left

`(<< e1 e2)`
 evaluates to: e1<< e2 where the << operation shifts its left hand side left by the number of bits specified by its right hand side. example: `(<< 7 2 )` evaluates to 28. In binary: 111 << 2 = 11100

#### Operation Shift Right

`(>> e1 e2)`

 evaluates to: e1 >> e2 (as in << except with a right shift) example: `(>> 7 2)` evaluates to 1. In binary: 111 >> 2 = 001

#### Bitwise Exclusive OR Operator

`(^ e1 e2 [e3...])`

 evaluates to: e1^ e2 [^ e3...] example: (^ 11 26) evaluates to 17. In binary: 01011" 11010 = 10001

#### Bitwise AND Operator

 `(& e1 e2 [e3...])` evaluates to: e1 &e2 [& e3...] example: `(& 11 26)` evaluates to 10. In binary: 01011 & 11010 = 01010

#### Bitwise OR Operator

 `(| e1 e2 [e3...])` evaluates to: e2 [| e3...] example: `(| 11 26)` evaluates to 27. In binary: 01011 111010 = 11011

#### Bitwise NOT

 `(~ e1)` evaluates to: the bitwise not of e1 (all 1 bits are changed to 0 and all 0 bits are changed to 1). example: `(~ 11)` evaluates to -12. In binary: ~01011 = 1111111111110100 (all the leading 0s in the 16 bit number change to 1s).

### Boolean Primitives

These procedures evaluate their parameters from left to right and terminate the moment the truth value of the expression is determined. If the truth value of the Boolean expression is determined before an expression is reached, that expression is never evaluated. Brackets [...] indicate optional entries. The compiler predefines FALSE to be 0 and TRUE to be 1.

#### Greater Than

|`(> e1 e2 [e3...])`

 evaluates to: TRUE if e1 > e2 [> e3...], else FALSE. example: (> 7 4 6) evaluates to FALSE.

#### Greater Than or Equals

`(>= e1 e2 [e3...])`

 evaluates to: TRUE if e1 >= e2 [>= e3...], else FALSE. example: `(>= 7 4 4)` evaluates to TRUE.

#### Less Than

`(< e1 e2 [e3...])`

 evaluates to: TRUE if e1 < e2 [< e3...], else FALSE. example: `(< 2 4 5)` evaluates to TRUE.

#### Less Than or Equals

`(<= e1 e2 [e3...])`

 evaluates to: TRUE if e1 <= e2 [<= e3...], else FALSE. example: `(<= 7 8 7)` evaluates to FALSE.

#### Is Equal To

`(== e1 e2 [e3...])`

 evaluates to: TRUE if e1 == e2 [== e3...], else FALSE. example: `(== 1 TRUE 1)` evaluates to TRUE.

#### Is Not Equal To

`(!= e1 e2 [e3...])`

 evaluates to: TRUE if e1 != e2 [!= e3...], else FALSE. example: `( ! = 7 4 6)` evaluates to TRUE.

#### AND

`(and e1 e2 [e3...])`

 evaluates to: TRUE if all the expressions are non-zero, else FALSE. example: `(and 7 4 6)` evaluates to TRUE.

#### OR

`(or e1 e2 [e3...])`

 evaluates to: TRUE if any of the expressions are non-zero, else FALSE. example: `(or 3 0 2)` evaluates to TRUE.

#### NOT

`(not el)`

 evaluates to: TRUE if the expression is zero, else FALSE. example: `(not 6)` evaluates to FALSE.

### Assignment Primitives

All assignment procedures store a value in a variable and return that value as the result of the assignment. In the following, v is a variable and e is an expression.

 `(= v e)` evaluates to v = e `(+= v e)` evaluates to v = v + e `(-= v e)` evaluates to v = v - e `(*= v e)` evaluates to v = v * e `(/= v e)` evaluates to v = v / e `(|= v e)` evaluates to v = v | e `(&= v e)` evaluates to v = v & e `(^= v e)` evaluates to v = v ^ e `(>>= v e)` evaluates to v = v >> e `(<<= v e)` evaluates to v = v << e `(++ v)` evaluates to v = v + 1 `(--v)` evaluates to v = v - 1
Notes