#### 4.4Primitive Operation Names

 prim-op
The name of a primitive operation can be used as an expression. It produces a function version of the operation.

 < : (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
 add1 : (number -> 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, by juxtaposition of the items
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
caadr :
 ((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
cadar :
 ((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
cdadr :
 ((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
 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?)
 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
 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 : (any ... -> void)
Purpose: to signal an error, combining the given values into an error message. If any of the values’ printed representations is too long, it is truncated and “...” is put into the string. If the first value is a symbol, it is treated specially; it is suffixed with a colon and a space (the intention is that the symbol is the name of the function signalling the error).
 exit : (-> void)
Purpose: to exit the running program
 identity : (any -> any)
Purpose: to return the argument unchanged
 struct? : (any -> boolean)
Purpose: to determine whether some value is a structure
 * : (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