5.14Primitive Operations

 < : (real real real ... -> boolean)
Purpose: to compare real numbers for less-than
 <= : (real real real ... -> boolean)
Purpose: to compare real numbers for less-than or equality
 = : (number number number ... -> boolean)
Purpose: to compare numbers for equality
 > : (real real real ... -> boolean)
Purpose: to compare real numbers for greater-than
 >= : (real real ... -> boolean)
Purpose: to compare real numbers for greater-than or equality
 abs : (real -> real)
Purpose: to compute the absolute value of a real number
 acos : (number -> number)
Purpose: to compute the arccosine (inverse of cos) of a number
Purpose: to compute a number one larger than a given number
 angle : (number -> real)
Purpose: to extract the angle from a complex number
 asin : (number -> number)
Purpose: to compute the arcsine (inverse of sin) of a number
 atan : (number -> number)
Purpose: to compute the arctan (inverse of tan) of a number
 ceiling : (real -> integer)
Purpose: to determine the closest integer (exact or inexact) above a real number
 complex? : (any -> boolean)
Purpose: to determine whether some value is complex
 conjugate : (number -> number)
Purpose: to compute the conjugate of a complex number
 cos : (number -> number)
Purpose: to compute the cosine of a number (radians)
 cosh : (number -> number)
Purpose: to compute the hyperbolic cosine of a number
 current-seconds : (-> integer)
Purpose: to compute the current time in seconds elapsed (since a platform-specific starting date)
 denominator : (rat -> integer)
Purpose: to compute the denominator of a rational
 e : real
Purpose: Euler’s number
 even? : (integer -> boolean)
Purpose: to determine if some integer (exact or inexact) is even or not
 exact->inexact : (number -> number)
Purpose: to convert an exact number to an inexact one
 exact? : (number -> boolean)
Purpose: to determine whether some number is exact
 exp : (number -> number)
Purpose: to compute e raised to a number
 expt : (number number -> number)
Purpose: to compute the power of the first to the second number
 floor : (real -> integer)
Purpose: to determine the closest integer (exact or inexact) below a real number
 gcd : (integer integer ... -> integer)
Purpose: to compute the greatest common divisior of two integers (exact or inexact)
 imag-part : (number -> real)
Purpose: to extract the imaginary part from a complex number
 inexact->exact : (number -> number)
Purpose: to approximate an inexact number by an exact one
 inexact? : (number -> boolean)
Purpose: to determine whether some number is inexact
 integer->char : (integer -> char)
Purpose: to lookup the character that corresponds to the given integer (exact only!) in the ASCII table (if any)
 integer-sqrt : (number -> integer)
Purpose: to compute the integer (exact or inexact) square root of a number
 integer? : (any -> boolean)
Purpose: to determine whether some value is an integer (exact or inexact)
 lcm : (integer integer ... -> integer)
Purpose: to compute the least common multiple of two integers (exact or inexact)
 log : (number -> number)
Purpose: to compute the base-e logarithm of a number
 magnitude : (number -> real)
Purpose: to determine the magnitude of a complex number
 make-polar : (real real -> number)
Purpose: to create a complex from a magnitude and angle
 make-rectangular : (real real -> number)
Purpose: to create a complex from a real and an imaginary part
 max : (real real ... -> real)
Purpose: to determine the largest number
 min : (real real ... -> real)
Purpose: to determine the smallest number
 modulo : (integer integer -> integer)
Purpose: to find the remainder of the division of the first number by the second; try (modulo 4 3) (modulo 4 -3)
 negative? : (number -> boolean)
Purpose: to determine if some value is strictly smaller than zero
 number->string : (number -> string)
Purpose: to convert a number to a string
 number? : (any -> boolean)
Purpose: to determine whether some value is a number
 numerator : (rat -> integer)
Purpose: to compute the numerator of a rational
 odd? : (integer -> boolean)
Purpose: to determine if some integer (exact or inexact) is odd or not
 pi : real
Purpose: the ratio of a circle’s circumference to its diameter
 positive? : (number -> boolean)
Purpose: to determine if some value is strictly larger than zero
 quotient : (integer integer -> integer)
Purpose: to divide the first integer (exact or inexact) into the second; try (quotient 3 4) and (quotient 4 3)
 random : (integer -> integer)
Purpose: to generate a random natural number less than some given integer (exact only!)
 rational? : (any -> boolean)
Purpose: to determine whether some value is a rational number
 real-part : (number -> real)
Purpose: to extract the real part from a complex number
 real? : (any -> boolean)
Purpose: to determine whether some value is a real number
 remainder : (integer integer -> integer)
Purpose: to determine the remainder of dividing the first by the second integer (exact or inexact)
 round : (real -> integer)
Purpose: to round a real number to an integer (rounds to even to break ties)
 sgn : (real -> (union 1 1.0 0 0.0 -1 -1.0))
Purpose: to compute the sign of a real number
 sin : (number -> number)
Purpose: to compute the sine of a number (radians)
 sinh : (number -> number)
Purpose: to compute the hyperbolic sine of a number
 sqr : (number -> number)
Purpose: to compute the square of a number
 sqrt : (number -> number)
Purpose: to compute the square root of a number
 sub1 : (number -> number)
Purpose: to compute a number one smaller than a given number
 tan : (number -> number)
Purpose: to compute the tangent of a number (radians)
 zero? : (number -> boolean)
Purpose: to determine if some value is zero or not
 boolean=? : (boolean boolean -> boolean)
Purpose: to determine whether two booleans are equal
 boolean? : (any -> boolean)
Purpose: to determine whether some value is a boolean
 false? : (any -> boolean)
Purpose: to determine whether a value is false
 not : (boolean -> boolean)
Purpose: to compute the negation of a boolean value
 symbol->string : (symbol -> string)
Purpose: to convert a symbol to a string
 symbol=? : (symbol symbol -> boolean)
Purpose: to determine whether two symbols are equal
 symbol? : (any -> boolean)
Purpose: to determine whether some value is a symbol
 append : ((listof any) ... -> (listof any))
Purpose: to create a single list from several
assq :
 (X (listof (cons X Y)) -> (union false (cons X Y)))
Purpose: to determine whether some item is the first item of a pair in a list of pairs
caaar :
 ((cons (cons (cons W (listof Z)) (listof Y)) (listof X)) -> W)
Purpose: to select the first item of the first list in the first list of a list
 ((cons (cons (cons W (listof Z)) (listof Y)) (listof X)) -> (listof Z))
Purpose: to select the rest of the first list in the first list of a list
 caar : ((cons (cons Z (listof Y)) (listof X)) -> Z)
Purpose: to select the first item of the first list in a list
 ((cons (cons W (cons Z (listof Y))) (listof X)) -> Z)
Purpose: to select the second item of the first list of a list
 cadddr : ((listof Y) -> Y)
Purpose: to select the fourth item of a non-empty list
 caddr : ((cons W (cons Z (cons Y (listof X)))) -> Y)
Purpose: to select the third item of a non-empty list
 cadr : ((cons Z (cons Y (listof X))) -> Y)
Purpose: to select the second item of a non-empty list
 car : ((cons Y (listof X)) -> Y)
Purpose: to select the first item of a non-empty list
cdaar :
 ((cons (cons (cons W (listof Z)) (listof Y)) (listof X)) -> (listof Z))
Purpose: to select the rest of the first list in the first list of a list
 ((cons W (cons (cons Z (listof Y)) (listof X))) -> (listof Y))
Purpose: to select the rest of the first list in the rest of a list
cdar :
 ((cons (cons Z (listof Y)) (listof X)) -> (listof Y))
Purpose: to select the rest of a non-empty list in a list
cddar :
 ((cons (cons W (cons Z (listof Y))) (listof X)) -> (listof Y))
Purpose: to select the rest of the rest of the first list of a list
cdddr :
 ((cons W (cons Z (cons Y (listof X)))) -> (listof X))
Purpose: to select the rest of the rest of the rest of a list
 cddr : ((cons Z (cons Y (listof X))) -> (listof X))
Purpose: to select the rest of the rest of a list
 cdr : ((cons Y (listof X)) -> (listof X))
Purpose: to select the rest of a non-empty list
 cons : (X (listof X) -> (listof X))
Purpose: to construct a list
 cons? : (any -> boolean)
Purpose: to determine whether some value is a constructed list
 eighth : ((listof Y) -> Y)
Purpose: to select the eighth item of a non-empty list
 empty? : (any -> boolean)
Purpose: to determine whether some value is the empty list
 fifth : ((listof Y) -> Y)
Purpose: to select the fifth item of a non-empty list
 first : ((cons Y (listof X)) -> Y)
Purpose: to select the first item of a non-empty list
 fourth : ((listof Y) -> Y)
Purpose: to select the fourth item of a non-empty list
 length : ((listof any) -> number)
Purpose: to compute the number of items on a list
 list : (any ... -> (listof any))
Purpose: to construct a list of its arguments
 list* : (any ... (listof any) -> (listof any))
Purpose: to construct a list by adding multiple items to a list
 list-ref : ((listof X) natural-number -> X)
Purpose: to extract the indexed item from the list
 list? : (any -> boolean)
Purpose: to determine whether some value is a list
 make-list : (natural-number any -> (listof any))
Purpose: (make-list k x) constructs a list of k copies of x
 member : (any (listof any) -> boolean)
Purpose: to determine whether some value is on the list (comparing values with equal?)
 memq : (any (listof any) -> (union false list))
Purpose: to determine whether some value is on some list if so, it produces the suffix of the list that starts with x if not, it produces false. (It compares values with the eq? predicate.)
 memv : (any (listof any) -> (union false list))
Purpose: to determine whether some value is on the list if so, it produces the suffix of the list that starts with x if not, it produces false. (it compares values with the eqv? predicate.)
 null : empty
Purpose: the empty list
 null? : (any -> boolean)
Purpose: to determine whether some value is the empty list
 pair? : (any -> boolean)
Purpose: to determine whether some value is a constructed list
 remove : (any (listof any) -> (listof any))
Purpose: to construct a list like the given one with the first occurrence of the given item removed (comparing values with equal?)
 rest : ((cons Y (listof X)) -> (listof X))
Purpose: to select the rest of a non-empty list
 reverse : ((listof any) -> list)
Purpose: to create a reversed version of a list
 second : ((cons Z (cons Y (listof X))) -> Y)
Purpose: to select the second item of a non-empty list
 seventh : ((listof Y) -> Y)
Purpose: to select the seventh item of a non-empty list
 sixth : ((listof Y) -> Y)
Purpose: to select the sixth item of a non-empty list
 third : ((cons W (cons Z (cons Y (listof X)))) -> Y)
Purpose: to select the third item of a non-empty list
 make-posn : (number number -> posn)
Purpose: to construct a posn
 posn-x : (posn -> number)
Purpose: to extract the x component of a posn
 posn-y : (posn -> number)
Purpose: to extract the y component of a posn
 posn? : (anything -> boolean)
Purpose: to determine if its input is a posn
 set-posn-x! : (posn number -> void)
Purpose: to update the x component of a posn
 set-posn-y! : (posn number -> void)
Purpose: to update the x component of a posn
 char->integer : (char -> integer)
Purpose: to lookup the number that corresponds to the given character in the ASCII table (if any)
 char-alphabetic? : (char -> boolean)
Purpose: to determine whether a character represents an alphabetic character
 char-ci<=? : (char char char ... -> boolean)
Purpose: to determine whether a character precedes another (or is equal to it) in a case-insensitive manner
 char-ci boolean)
Purpose: to determine whether a character precedes another in a case-insensitive manner
 char-ci=? : (char char char ... -> boolean)
Purpose: to determine whether two characters are equal in a case-insensitive manner
 char-ci>=? : (char char char ... -> boolean)
Purpose: to determine whether a character succeeds another (or is equal to it) in a case-insensitive manner
 char-ci>? : (char char char ... -> boolean)
Purpose: to determine whether a character succeeds another in a case-insensitive manner
 char-downcase : (char -> char)
Purpose: to determine the equivalent lower-case character
 char-lower-case? : (char -> boolean)
Purpose: to determine whether a character is a lower-case character
 char-numeric? : (char -> boolean)
Purpose: to determine whether a character represents a digit
 char-upcase : (char -> char)
Purpose: to determine the equivalent upper-case character
 char-upper-case? : (char -> boolean)
Purpose: to determine whether a character is an upper-case character
 char-whitespace? : (char -> boolean)
Purpose: to determine whether a character represents space
 char<=? : (char char char ... -> boolean)
Purpose: to determine whether a character precedes another (or is equal to it)
 char boolean)
Purpose: to determine whether a character precedes another
 char=? : (char char char ... -> boolean)
Purpose: to determine whether two characters are equal
 char>=? : (char char char ... -> boolean)
Purpose: to determine whether a character succeeds another (or is equal to it)
 char>? : (char char char ... -> boolean)
Purpose: to determine whether a character succeeds another
 char? : (any -> boolean)
Purpose: to determine whether a value is a character
 explode : (string -> (listof string))
Purpose: to translate a string into a list of 1-letter strings
 format : (string any ... -> string)
Purpose: to format a string, possibly embedding values
 implode : ((listof string) -> string)
Purpose: to concatenate the list of 1-letter strings into one string
 int->string : (integer -> string)
Purpose: to convert an integer in [0,55295] or [57344 1114111] to a 1-letter string
 list->string : ((listof char) -> string)
Purpose: to convert a s list of characters into a string
 make-string : (nat char -> string)
Purpose: to produce a string of given length from a single given character
 replicate : (nat string -> string)
Purpose: to replicate the given string
 string : (char ... -> string)
Purpose: (string c1 c2 ...) builds a string
 string->int : (string -> integer)
Purpose: to convert a 1-letter string to an integer in [0,55295] or [57344, 1114111]
 string->list : (string -> (listof char))
Purpose: to convert a string into a list of characters
 string->number : (string -> (union number false))
Purpose: to convert a string into a number, produce false if impossible
 string->symbol : (string -> symbol)
Purpose: to convert a string into a symbol
 string-alphabetic? : (string -> boolean)
Purpose: to determine whether all ’letters’ in the string are alphabetic
 string-append : (string ... -> string)
Purpose: to juxtapose the characters of several strings
 string-ci<=? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically precedes another (or is equal to it) in a case-insensitive manner
 string-ci boolean)
Purpose: to determine whether one string alphabetically precedes another in a case-insensitive manner
 string-ci=? : (string string string ... -> boolean)
Purpose: to compare two strings character-wise in a case-insensitive manner
 string-ci>=? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically succeeds another (or is equal to it) in a case-insensitive manner
 string-ci>? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically succeeds another in a case-insensitive manner
 string-copy : (string -> string)
Purpose: to copy a string
 string-ith : (string nat -> string)
Purpose: to extract the ith 1-letter substring from the given one
 string-length : (string -> nat)
Purpose: to determine the length of a string
 string-lower-case? : (string -> boolean)
Purpose: to determine whether all ’letters’ in the string are lower case
 string-numeric? : (string -> boolean)
Purpose: to determine whether all ’letters’ in the string are numeric
 string-ref : (string nat -> char)
Purpose: to extract the i-the character from a string
 string-upper-case? : (string -> boolean)
Purpose: to determine whether all ’letters’ in the string are upper case
 string-whitespace? : (string -> boolean)
Purpose: to determine whether all ’letters’ in the string are white space
 string<=? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically precedes another (or is equal to it)
 string boolean)
Purpose: to determine whether one string alphabetically precedes another
 string=? : (string string string ... -> boolean)
Purpose: to compare two strings character-wise
 string>=? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically succeeds another (or is equal to it)
 string>? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically succeeds another
 string? : (any -> boolean)
Purpose: to determine whether a value is a string
 substring : (string nat nat -> string)
Purpose: to extract the substring starting at a 0-based index up to the second 0-based index (exclusive)
 image=? : (image image -> boolean)
Purpose: to determine whether two images are equal
 image? : (any -> boolean)
Purpose: to determine whether a value is an image
 =~ : (real real non-negative-real -> boolean)
Purpose: to check whether two real numbers are within some amount (the third argument) of either other
 eof : eof
Purpose: the end-of-file value
 eof-object? : (any -> boolean)
Purpose: to determine whether some value is the end-of-file value
 eq? : (any any -> boolean)
Purpose: to determine whether two values are equivalent from the computer’s perspective (intensional)
 equal? : (any any -> boolean)
Purpose: to determine whether two values are structurally equal where basic values are compared with the eqv? predicate
 equal~? : (any any non-negative-real -> boolean)
Purpose: to compare like equal? on the first two arguments, except using =~ in the case of real numbers
 eqv? : (any any -> boolean)
Purpose: to determine whether two values are equivalent from the perspective of all functions that can be applied to it (extensional)
 error : (string -> void)
Purpose: to signal an error
 exit : (-> void)
Purpose: to exit the running program
 force : (delay -> any)
 identity : (any -> any)
Purpose: to return the argument unchanged
 promise? : (any -> boolean)
Purpose: to determine if a value is delayed
 struct? : (any -> boolean)
Purpose: to determine whether some value is a structure
 void : (-> void)
Purpose: produces a void value
 void? : (any -> boolean)
Purpose: to determine if a value is void
 * : (number ... -> number)
Purpose: to multiply all given numbers
 + : (number ... -> number)
Purpose: to add all given numbers
 - : (number ... -> number)
Purpose: to subtract from the first all remaining numbers
 / : (number ... -> number)
Purpose: to divide the first by all remaining numbers
 andmap : ((X -> boolean) (listof X) -> boolean)
Purpose: (andmap p (list x-1 ... x-n)) = (and (p x-1) ... (p x-n))
apply :
 ((X-1 ... X-N -> Y) X-1 ... X-i (list X-i+1 ... X-N) -> Y)
Purpose: to apply a function using items from a list as the arguments
 argmax : ((X -> real) (listof X) -> X)
Purpose: to find the (first) element of the list that maximizes the output of the function
 argmin : ((X -> real) (listof X) -> X)
Purpose: to find the (first) element of the list that minimizes the output of the function
 build-list : (nat (nat -> X) -> (listof X))
Purpose: (build-list n f) = (list (f 0) ... (f (- n 1)))
 build-string : (nat (nat -> char) -> string)
Purpose: (build-string n f) = (string (f 0) ... (f (- n 1)))
compose :
 ((Y-1 -> Z) ... (Y-N -> Y-N-1) (X-1 ... X-N -> Y-N) -> (X-1 ... X-N -> Z))
Purpose: to compose a sequence of procedures into a single procedure
 filter : ((X -> boolean) (listof X) -> (listof X))
Purpose: to construct a list from all those items on a list for which the predicate holds
 foldl : ((X Y -> Y) Y (listof X) -> Y)
Purpose: (foldl f base (list x-1 ... x-n)) = (f x-n ... (f x-1 base))
 foldr : ((X Y -> Y) Y (listof X) -> Y)
Purpose: (foldr f base (list x-1 ... x-n)) = (f x-1 ... (f x-n base))
 for-each : ((any ... -> any) (listof any) ... -> void)
Purpose: to apply a function to each item on one or more lists for effect only
 map : ((X ... -> Z) (listof X) ... -> (listof Z))
Purpose: to construct a new list by applying a function to each item on one or more existing lists
memf :
 ((X -> boolean) (listof X) -> (union false (listof X)))
Purpose: to determine whether the first argument produces true for some value in the second argument
 ormap : ((X -> boolean) (listof X) -> boolean)
Purpose: (ormap p (list x-1 ... x-n)) = (or (p x-1) ... (p x-n))
 procedure? : (any -> boolean)
Purpose: to determine if a value is a procedure
 quicksort : ((listof X) (X X -> boolean) -> (listof X))
Purpose: to construct a list from all items on a list in an order according to a predicate
 sort : ((listof X) (X X -> boolean) -> (listof X))
Purpose: to construct a list from all items on a list in an order according to a predicate
 display : (any -> void)
Purpose: to print the argument to stdout (without quotes on symbols and strings, etc.)
 newline : (-> void)
Purpose: to print a newline to stdout
 pretty-print : (any -> void)
Purpose: like write, but with standard newlines and indentation
 print : (any -> void)
Purpose: to print the argument as a value to stdout
 printf : (string any ... -> void)
Purpose: to format the rest of the arguments according to the first argument and print it to stdout
Purpose: to read input from the user
 write : (any -> void)
Purpose: to print the argument to stdout (in a traditional style that is somewhere between print and display)
 build-vector : (nat (nat -> X) -> (vectorof X))
Purpose: to construct a vector
 make-vector : (number X -> (vectorof X))
Purpose: to construct a vector
 vector : (X ... -> (vector X ...))
Purpose: to construct a vector
 vector-length : ((vector X) -> nat)
Purpose: to determine the length of a vector
 vector-ref : ((vector X) nat -> X)
Purpose: to extract an element from a vector
 vector-set! : ((vectorof X) nat X -> void)
Purpose: to update a vector
 vector? : (any -> boolean)
Purpose: to determine if a value is a vector
 box : (any -> box)
Purpose: to construct a box
 box? : (any -> boolean)
Purpose: to determine if a value is a box
 set-box! : (box any -> void)
Purpose: to update a box
 unbox : (box -> any)
Purpose: to extract the boxed value