`(`

— Create a new image with images **above** i1 i2 ... in [description])`i1`

through `in`

placed in a stack,
each above the next.

`(`

— Returns a predicate of one parameter, **all-of** pred_1? ... pred_n?)`val`

, that checks whether all
of `pred_1?`

… `pred_n?`

hold on `val`

.

`(`

— Evaluate each expression in turn until one of them returns false
or we run out expressions. In the former case, returns false
(**and** exp1 exp2 ... expn)`#f`

). In the latter case, returns the value of `expn`

.

`(`

— Returns a predicate of one parameter, **any-of** pred_1? ... pred_n?)`val`

, that checks whether any
of `pred_1?`

… `pred_n?`

hold on `val`

.

`(`

— Place **beside/align** valignment i1 i2 ... in [description])`i1`

through `in`

in a row beside one another, aligned as
described.

`(`

— ;; description : string?
Create an image with **beside** i1 i2 ... in [description])`i1`

through `in`

placed beside each other
in a row.

`(`

— Grabs the first element of the pair.**car** pair)

`(`

— Grabs the first element of **car** lst)`lst`

.

`(`

— Grabs the second element of the pair.**cdr** pair)

`(`

— Grabs all but the first element of **cdr** lst)`lst`

.

`(`

— Determine if the image is a circle.**circle?** img)

`(`

— Determines if **compound-image?** val)`val`

is a compound image, one build by combining
other images (e.g., with `overlay`

, `beside`

, or `above`

).

`(`

— Evaluate each guard in turn until one holds (is not false). Then evaluate
each of the corresponding expressions. Return the value of the last
corresponding expression. If none of the guards holds, evaluate each
of **cond** [guard0 exp0a exp0b ...] [guard1 exp1a exp1b ...] ... [else alt0 alt1 ... altn])`alt0`

through `altn`

, returning the value of `altn`

.

`(`

— Create a pair from **cons** val1 val2)`val1`

and `val2`

.

`(`

— Create a new list by adding **cons** val lst)`val`

to the front of `lst`

.

`(`

— Crop **crop** img left top width height [description])`img`

with the left edge at `left`

, the top edge at `top`

,
and the specified width and height.

`(`

— Create a curve from **curve** source source-angle source-pull target target-angle target-pull color line-width [description])`source`

to `target`

. The curve leaves
`source`

at the specified angle and enters `target`

from the
specified angle.

`(`

— Get the description of the image.**describe-image** img)

`(`

— Determine the height of an ellipse. For outlined ellipses, this is
the height of the inner ellipse.**ellipse-height** ell)

`(`

— Determine if an image is an ellipse.**ellipse?** img)

`(`

— Determine the width of an ellipse. For outlined ellipses, this is
the width of the inner ellipse.**ellipse-width** ell)

`(`

— Flip **hflip** img [description])`img`

horizontally.

`(`

— Evaluate **if** guard consequent alternate)`guard`

. If it holds (is not `#f`

), evaluate `consequent`

and return its value. If `guard`

evaluates to `#f`

, evavluate the
`alternate`

and return its value.

`(`

— Get the color of this image. Returns false if its a type of
image that does not have a natural color.**image-color** img)

`(`

— Get the height of the image.**image-height** img)

`(`

— Apply a function to each basic image in an image.**image-map** fun img)

`(`

— “Subtract” **image-subtract** img1 img2 [description])`img2`

from `img1`

, decreasing the opacity of each
pixel in `img1`

by the opacity of the corresponding pixel in
`img2`

. `image-subtract`

does not otherwise affect the colors
in `img1`

.

`(`

— Get the width of the image.**image-width** img)

`(`

— Builds a unary predicate that verifies that its parameter is a list,
all of whose elements match **list-of** pred?)`pred?`

.

`(`

— Grabs the element at index **list-ref** lst pos)`pos`

from `lst`

. Elements in lists are
indexed starting at 0, so `(list-ref lst 0)`

grabs the first element
of the list.

`(`

— Create a list from the specified values.**list** val_1 ... val_n)

`(`

— Create the complex number that corresponds to the end of a vector
of the given radius and angle from the origin.**make-polar** radius angle)

`(`

— Returns a procedure that returns the negation of **negate?** proc)`proc`

. That is,
returns a procedure that returns `not`

of the result of `proc`

.

`(`

— Determines if **nonnegative?** val)`val`

is non-negative (greater than or equal to 0).

`(`

— If **not** val)`val`

is false (`#f`

), return true (`#t`

). If `val`

is anything
else, return false.

`(`

— Evaluate each expression in turn until one of them returns a
truish value (one that is not false). Return that value. If
all of the expressions return false, returns false.**or** exp1 exp2 ... expn)

`(`

— Create an outlined circle with the given diameter and color.**outlined-circle** diameter color [description])

`(`

— An outlined equilateral-triangle whose inner size is width-by-height with
an outline of **outlined-equilateral-triangle** width height color line-width [desc])`line-width`

. The inner triangle is transparent.

`(`

— Create a polygon whose vertices are given by **outlined-polygon** points color pen-width [description])`points`

and which
is outlined by a `color`

line whose width is given by `line-width`

.

`(`

— A rectangle of the specified width and height, outlined with a
line of the specified color and width.**outlined-rectangle** width height color line-width [description])

`(`

— Create an outlined square with the given side length and color.**outlined-square** side color line-width [description])

`(`

— Overlay the two images, aligning them as described.**overlay/align** halignment valignment i1 i2 ... in [description])

`(`

— Overlay **overlay** img1 ... imgn [description])`img1`

through `imgn`

on top of each other, keeping them centered
on each other.

`(`

— Place **place** img xside x yside y bg)`img`

on `bg`

, with the `xside`

of `img`

at `x`

and the
`yside`

of `img`

at `y`

. Crop the result at the edges of `bg`

.

`(`

— Determines whether **polygon?** img)`img`

is a polygon.

`(`

— Make a point.**pt** x y)

`(`

— Compute an unpredictable number between 0 (inclusive) and 1 (exclusive).**random**)

`(`

— Compute an unpredictable number between 0 (inclusive) and **random** n)`n`

(exclusive).

`(`

— Compute an unpredictable number between **random** lb ub)`lb`

(inclusive) and
`ub`

(exclusive).

`(`

— Convert **rgb-greyscale** c)`c`

to greyscale (or approximately greyscale).

`(`

— Extract the red component of an RGB(A) color.**rgb-red** rgb-color)

`(`

— Create a new image by rotating **rotate** img angle [description])`img`

by `angle`

degrees
counter-clockwise.

`(`

— Create a solid circle with the given diameter and color.**solid-circle** diameter color [description])

`(`

— Create a **solid-ellipse** width height color [description])`width`

-by-`height`

ellipse whose color is `color`

.

`(`

— Determines if **solid-equilateral-triangle?** val)`val`

is a solid equilateral triangle.

`(`

— A solid equilateral triangle of the given edge length and color.**solid-equilateral-triangle** edge color [description])

`(`

— Create a polygon whose vertices are given by **solid-polygon** points color [description])`points`

and whose
color is `color`

.

`(`

— A polygon whose vertices are given by **solid-rectangle** width height color [description])`points`

and whose color is `color`

.

`(`

— Create a solid square with the given side length and color.**solid-square** side color [description])

`(`

— Determines if **square?** img)`img`

is a square (solid or outlined).

`(`

— Get a list of all the subimages of the current image.**subimages** img)

`(`

— Builds a unary predicate that verifies that its parameter is a vector,
all of whose elements match **vector-of** pred?)`pred?`

.

`(`

— Flip **vflip** img [description])`img`

vertically.