Constants
(constant) Infinity :number
The name
Infinity
refers to the special number value Infinity
.
See ECMAScript Specification, Section 4.3.23
Type:
 number
(constant) math_E :number
The Number value for e, Euler's number,
which is approximately 2.718281828459045.
Type:
 number
(constant) math_LN2 :number
The Number value for the natural logarithm of 2,
which is approximately 0.6931471805599453.
Type:
 number
(constant) math_LN10 :number
The Number value for the natural logarithm of 10,
which is approximately 2.302585092994046.
Type:
 number
(constant) math_LOG2E :number
The Number value for the base2 logarithm of eℝ, the base of the natural logarithms;
this value is approximately 1.4426950408889634.
NOTE: The value of math_LOG2E is approximately the reciprocal of the value of math_LN2.
Type:
 number
(constant) math_LOG10E :number
The Number value for the base10 logarithm of e,
the base of the natural logarithms; this value is approximately 0.4342944819032518.
NOTE: The value of math_LOG10E is approximately the reciprocal of the value of math_LN10.
Type:
 number
(constant) math_PI :number
The Number value for π, the ratio of the circumference of a circle to its diameter,
which is approximately 3.1415926535897932.
Type:
 number
(constant) math_SQRT1_2 :number
The Number value for the square root of 0.5, which is approximately 0.7071067811865476.
NOTE: The value of math_SQRT1_2 is approximately the reciprocal of the value of math_SQRT2.
Type:
 number
(constant) math_SQRT2 :number
The Number value for the square root of 2, which is approximately 1.4142135623730951.
Type:
 number
(constant) NaN :number
The name
NaN
refers to the special number value NaN
("not a number"). Note that
NaN
is a number, as specified by is_number
.
See ECMAScript Specification, Section 4.3.24
Type:
 number
(constant) undefined :undefined
The name
undefined
refers to the special value undefined
.
See also textbook explanation in section 4.1.1.
Type:
Functions
__access_export__(exports, lookup_name) → {value}
Searches for the specified name in the data structure of exported names.
The data structure is a pair where the head element is the default export
and the tail element is a list of pairs where each pair is a mapping from
the exported name to the value being exported. If the lookup name is
"default", the default export is returned instead of a named export. If
the name does not exist,
undefined
is returned.
Parameters:
Name  Type  Description 

exports 
pair  The data structure of exported values 
lookup_name 
string  Name to import 
Returns:
The value corresponding to the imported name
 Type
 value
__access_named_export__(named_exports, lookup_name) → {value}
Searches for the specified name in the data structure of exported names.
The data structure is a list of pairs where each pair is a mapping from
the exported name to the value being exported. If the name does not exist,
undefined
is returned.
Parameters:
Name  Type  Description 

named_exports 
list  The data structure of exported names 
lookup_name 
string  Name to import 
Returns:
The value corresponding to the imported name
 Type
 value
accumulate(f, initial, xs) → {value}
Applies binary
function
f
to the elements of xs
from
righttoleft order, first applying f
to the last element
and the value initial
, resulting in r
_{1},
then to the
secondlast element and r
_{1}, resulting in
r
_{2},
etc, and finally
to the first element and r
_{n1}, where
n
is the length of the
list. Thus, accumulate(f,zero,list(1,2,3))
results in
f(1, f(2, f(3, zero)))
.
Iterative process;
time: Theta(n)
(apart from f
), space: Theta(n)
(apart from f
),
where n
is the length of xs
.
Parameters:
Name  Type  Description 

f 
function  binary function 
initial 
value  initial value 
xs 
list  given list 
Returns:
result of accumulating
xs
using f
starting with initial
 Type
 value
append(xs, ys) → {list}
Returns a list that results from
appending the list
ys
to the list xs
.
Iterative process; time: Theta(n)
, space:
Theta(n)
, where n
is the length of xs
.
In the result, null at the end of the first argument list
is replaced by the second argument, regardless what the second
argument consists of.
Parameters:
Name  Type  Description 

xs 
list  given first list 
ys 
list  given second list 
Returns:
result of appending
xs
and ys
 Type
 list
arity(f) → {number}
Returns the number of parameters the given function
f
expects,
excluding the rest parameter.
Parameters:
Name  Type  Description 

f 
function  given function 
Returns:
number of parameters f expects
 Type
 number
array_length(x) → {number}
**primitive**; returns
the current length of array
x
, which is 1 plus the
highest index that has been used so far in an array assignment on
x
. Here literal array expressions are counted too: The
array [10, 20, 30]
has a length of 3.
Time: Θ(1)
, space: Θ(1)
Parameters:
Name  Type  Description 

x 
array  given array 
Returns:
current length of array
 Type
 number
build_list(f, n) → {list}
Makes a list with
n
elements by applying the unary function f
to the numbers 0 to n  1
, assumed to be a nonnegative integer.
Iterative process; time: Theta(n)
(apart from f
), space: Theta(n)
(apart from f
).
Parameters:
Name  Type  Description 

f 
function  unary function 
n 
number  given nonnegative integer 
Returns:
resulting list
 Type
 list
build_stream(f, n) → {stream}
Makes a stream with
n
elements by applying the unary function f
to the numbers 0 to n  1
, assumed to be a nonnegative integer.
Lazy? Yes: The result stream forces the application of f
for the next element
Parameters:
Name  Type  Description 

f 
function  unary function 
n 
number  given nonnegative integer 
Returns:
resulting stream
 Type
 stream
char_at(s, i) → {string}
Takes a string
s
as first argument and a nonnegative integer
i
as second argument. If i
is less than the length
of s
, this function returns a onecharacter string that contains
the character of s
at position i
, counting from 0.
If i
is larger than or equal to the length of
s
, this function returns undefined
.
Parameters:
Name  Type  Description 

s 
string  given string 
i 
number  index 
Returns:
onecharacter or undefined
 Type
 string
display(v, s) → {value}
Optional second argument. If present,
displays the given string
s
, followed by a space character, followed by the
value v
in the console.
If second argument not present,
just displays the value v
in the console.
The notation used for the display of values
is consistent with
JSON,
but also displays undefined
, NaN
, Infinity
, and function objects.
Parameters:
Name  Type  Description 

v 
value  to be displayed 
s 
string  to be displayed, preceding v , optional argument 
Returns:
v, the first argument value
 Type
 value
display_list(xs, s) → {value}
Optional second argument.
Similar to
display
, but formats wellformed lists nicely if detected;
time, space:
Theta(n)
, where n
is the total number of data structures such as
pairs in x
.
Parameters:
Name  Type  Description 

xs 
value  list structure to be displayed 
s 
string  to be displayed, preceding xs 
Returns:
xs, the first argument value
 Type
 value
draw_data() → {value}
visualizes the arguments in a separate drawing
area in the Source Academy using boxandpointer diagrams; time, space:
Theta(n)
, where n
is the total number of data structures such as
pairs in the arguments.
Parameters:
Name  Type  Description 

value1,value2,...,value_n 
value  given values 
Returns:
given
x
 Type
 value
enum_list(start, end) → {list}
Returns a list that enumerates
numbers starting from
start
using a step size of 1, until
the number exceeds (>
) end
.
Iterative process;
time: Theta(n)
, space: Theta(n)
,
where n
is end  start
.
Parameters:
Name  Type  Description 

start 
number  starting number 
end 
number  ending number 
Returns:
list from
start
to end
 Type
 list
enum_stream(start, end) → {stream}
Returns a stream that enumerates
numbers starting from
start
using a step size of 1, until
the number exceeds (>
) end
.
Lazy? Yes: The result stream forces the construction of
each next element
Parameters:
Name  Type  Description 

start 
number  starting number 
end 
number  ending number 
Returns:
stream from
start
to end
 Type
 stream
equal(x, y) → {boolean}
Returns
true
if both
have the same structure with respect to pair
,
and identical values at corresponding leave positions (places that are not
themselves pairs), and false
otherwise. For the "identical",
the values need to have the same type, otherwise the result is
false
. If corresponding leaves are boolean values, these values
need to be the same. If both are undefined
or both are
null
, the result is true
. Otherwise they are compared
with ===
(using the definition of ===
in the
respective Source language in use).
Time, space:
Theta(n)
, where n
is the total number of data structures such as
pairs in x
and y
.
Parameters:
Name  Type  Description 

x 
value  given value 
y 
value  given value 
Returns:
whether
x
is structurally equal to y
 Type
 boolean
error(v, s)
Optional second argument.
If present,
displays the given string
s
, followed by a space character, followed by the
value v
in the console with error flag.
If second argument not present,
just displays the value v
in the console with error flag.
The evaluation
of any call of error
aborts the running program immediately.
The notation used for the display of values
is consistent with
JSON,
but also displays undefined
, NaN
, Infinity
, and function objects.
Parameters:
Name  Type  Description 

v 
value  to be displayed 
s 
string  to be displayed, preceding v 
eval_stream(s, n) → {list}
Constructs the list of the first
n
elements
of a given stream s
Lazy? Sortof: eval_stream
only forces the computation of
the first n
elements, and leaves the rest of
the stream untouched.
Parameters:
Name  Type  Description 

s 
stream  given stream 
n 
number  nonnegative number of elements to place in result list 
Returns:
result list
 Type
 list
filter(pred, xs) → {list}
Returns a list that contains
only those elements for which the oneargument function
pred
returns true
.
Iterative process;
time: Theta(n)
(apart from pred
), space: Theta(n)
(apart from pred
),
where n
is the length of xs
.
Parameters:
Name  Type  Description 

pred 
function  unary function returning boolean value 
xs 
list  given list 
Returns:
list with those elements of
xs
for which pred
holds.
 Type
 list
for_each(f, xs) → {boolean}
Applies unary function
f
to every
element of the list xs
.
Iterative process; time: Theta(n)
(apart from f
), space: Theta(1)
(apart from f
),
where n
is the length of xs
.
f
is applied elementbyelement:
for_each(fun, list(1, 2))
results in the calls
fun(1)
and fun(2)
.
Parameters:
Name  Type  Description 

f 
function  unary 
xs 
list  given list 
Returns:
true
 Type
 boolean
get_time() → {number}
Returns number of milliseconds elapsed since January 1, 1970 00:00:00 UTC.
See also textbook example.
Returns:
current time in milliseconds
 Type
 number
head(p) → {value}
**primitive**; returns head (first component) of given pair
p
; time: Theta(1)Theta(1)
.
Parameters:
Name  Type  Description 

p 
pair  given pair 
Returns:
head of
p
 Type
 value
integers_from(start) → {stream}
Returns infinite stream if integers starting
at given number
n
using a step size of 1.
Lazy? Yes: The result stream forces the construction of
each next element
Parameters:
Name  Type  Description 

start 
number  starting number 
Returns:
infinite stream from
n
 Type
 stream
is_array(x) → {boolean}
**primitive**; returns
true
if x
is an array, and false
if it is not.
Time: Θ(1)
, space: Θ(1)
Parameters:
Name  Type  Description 

x 
value  given value 
Returns:
whether
x
is an array
 Type
 boolean
is_boolean(v) → {boolean}
checks whether a given value is a boolean
Parameters:
Name  Type  Description 

v 
value  to be checked 
Returns:
indicating whether the value is a boolean
 Type
 boolean
is_function(v) → {boolean}
checks whether a given value is a function
Parameters:
Name  Type  Description 

v 
value  to be checked 
Returns:
indicating whether the value is a function
 Type
 boolean
is_list(xs) → {xs}
**primitive**; returns
true
if
xs
is a list as defined in the textbook, and
false
otherwise. Iterative process;
time: Theta(n)
, space: Theta(1)
, where n
is the length of the
chain of tail
operations that can be applied to xs
.
is_list
recurses down the list and checks that it ends with the empty list null
Parameters:
Name  Type  Description 

xs 
value  given candidate 
Returns:
whether is a list
 Type
 xs
is_null(x) → {boolean}
**primitive**; returns
true
if x
is the
empty list null
, and false
otherwise; time: Theta(1)Theta(1)
.
Parameters:
Name  Type  Description 

x 
value  given value 
Returns:
whether
x
is null
 Type
 boolean
is_number(v) → {boolean}
checks whether a given value is a number.
See also textbook example.
Parameters:
Name  Type  Description 

v 
value  to be checked 
Returns:
indicating whether the value is a number
 Type
 boolean
is_pair(x) → {boolean}
**primitive**; returns
true
if x
is a
pair and false otherwise; time: Theta(1)Theta(1)
.
Parameters:
Name  Type  Description 

x 
value  given value 
Returns:
whether
x
is a pair
 Type
 boolean
is_stream(xs) → {boolean}
Returns
true
if
xs
is a stream as defined in the textbook, and
false
otherwise. Iterative process.
Recurses down the stream and checks that it ends with the empty stream null.
Laziness: No: is_stream
needs to force the given stream.
Parameters:
Name  Type  Description 

xs 
value  given candidate 
Returns:
whether
xs
is a stream
 Type
 boolean
is_string(v) → {boolean}
checks whether a given value is a string.
See also textbook example.
Parameters:
Name  Type  Description 

v 
value  to be checked 
Returns:
indicating whether the value is a string
 Type
 boolean
is_undefined(v) → {boolean}
checks whether a given value is the special value
undefined
Parameters:
Name  Type  Description 

v 
value  to be checked 
Returns:
indicating whether the value is
undefined
 Type
 boolean
length(xs) → {number}
Returns the length of the list
xs
.
Iterative process; time: Theta(n)
, space:
Theta(1)
, where n
is the length of xs
.
Parameters:
Name  Type  Description 

xs 
list  given list 
Returns:
length of
xs
 Type
 number
list() → {list}
**primitive**; given
n
values, returns a list of length n
.
The elements of the list are the given values in the given order; time: Theta(n)Theta(n)
.
Parameters:
Name  Type  Description 

value1,value2,...,value_n 
value  given values 
Returns:
list containing all values
 Type
 list
list_ref(xs, n) → {value}
Returns the element
of list
xs
at position n
,
where the first element has index 0.
Iterative process;
time: Theta(n)
, space: Theta(1)
,
where n
is the length of xs
.
Parameters:
Name  Type  Description 

xs 
list  given list 
n 
number  given position 
Returns:
item in
xs
at position n
 Type
 value
list_to_stream(xs) → {stream}
Given list
xs
, returns a stream of same length with
the same elements as xs
in the same order.
Laziness: Yes: list_to_stream
goes down the list only when forced.
Parameters:
Name  Type  Description 

xs 
list  given list 
Returns:
stream containing all elements of
xs
 Type
 stream
list_to_string(xs) → {string}
Returns a string that represents
list
xs
using the textbased boxandpointer notation
[...]
.
Iterative process; time: Theta(n)
where n
is the size of the list, space: Theta(m)
where m
is the length of the string.
The process is iterative, but consumes space O(m)
because of the result string.
Parameters:
Name  Type  Description 

xs 
list  given list 
Returns:
xs
converted to string
 Type
 string
map(f, xs) → {list}
Returns a list that results from list
xs
by elementwise application of unary function f
.
Iterative process; time: Theta(n)
(apart from f
),
space: Theta(n)
(apart from f
), where n
is the length of xs
.
f
is applied elementbyelement:
map(f, list(1, 2))
results in list(f(1), f(2))
.
Parameters:
Name  Type  Description 

f 
function  unary 
xs 
list  given list 
Returns:
result of mapping
 Type
 list
math_abs(x
) → {number}
computes the absolute value of x; the result has the same magnitude as
x
but has positive sign.
Parameters:
Name  Type  Description 


number  given number 
Returns:
absolute value of
x
 Type
 number
math_acos(x
) → {number}
computes the arc cosine of
x
.
The result is expressed in radians and ranges from +0 to +π.
Parameters:
Name  Type  Description 


number  given number 
Returns:
arc cosine of
x
 Type
 number
math_acosh(x
) → {number}
computes the inverse hyperbolic cosine of
x
.
Parameters:
Name  Type  Description 


number  given number 
Returns:
inverse hyperbolic cosine of
x
.
 Type
 number
math_asin(x
) → {number}
computes the arc sine of
x
. The result is expressed in radians and ranges from π / 2 to +π / 2.
Parameters:
Name  Type  Description 


number  given number 
Returns:
arc sine of
x
.
 Type
 number
math_asinh(x
) → {number}
computes the inverse hyperbolic
sine of
x
. The result is expressed in radians and ranges from π / 2 to +π / 2.
Parameters:
Name  Type  Description 


number  given number 
Returns:
inverse hyperbolic sine of
x
 Type
 number
math_atan(x
) → {number}
computes the arc tangent of
x
. The result is expressed in radians and ranges from π / 2 to +π / 2.
Parameters:
Name  Type  Description 


number  given number 
Returns:
arc tangent of
x
 Type
 number
math_atan2(y
, x
) → {number}
computes the arc tangent of the quotient
y
/ x
of the arguments y
and x
, where the signs of y
and x
are used to determine the quadrant of the result. Note that it is intentional and traditional for the twoargument arc tangent function that the argument named y
be first and the argument named x
be second. The result is expressed in radians and ranges from π to +π.
Parameters:
Name  Type  Description 


number  given first number 

number  given second number 
Returns:
arc tangent of
y
/ x
.
 Type
 number
math_atanh(x
) → {number}
computes the inverse hyperbolic tangent of
x
.
Parameters:
Name  Type  Description 


number  given number 
Returns:
inverse hyperbolic tangent of
x
.
 Type
 number
math_cbrt(x
) → {number}
computes the cube root of
x
.
Parameters:
Name  Type  Description 


number  given number 
Returns:
cube root of
x
.
 Type
 number
math_ceil(x
) → {number}
computes the smallest (closest to ∞) Number value that is not less than
x
and is an integer. If x
is already an integer, the result is x
.
The value of math_ceil(x) is the same as the value of math_floor(x).
Parameters:
Name  Type  Description 


number  given number 
Returns:
"ceiling" of the number
 Type
 number
math_clz32(n) → {number}
When math_clz32 is called with one argument
x
, the following steps are taken:
Let n be ToUint32(x).
Let p be the number of leading zero bits in the 32bit binary representation of n.
Return p.
NOTE:
If n is 0, p will be 32. If the most significant bit of the 32bit binary encoding of n is 1,
p will be 0.
Parameters:
Name  Type  Description 

n 
number  given number 
Returns:
p  leading zero bits
 Type
 number
math_cos(x
) → {number}
Computes the cosine of
x
.
The argument is expressed in radians.
Parameters:
Name  Type  Description 


number  given number 
Returns:
 cosine of
x
 Type
 number
math_cosh(x
) → {number}
computes the hyperbolic cosine of
x
.
NOTE: The value of cosh(x) is the same as (exp(x) + exp(x)) / 2.
Parameters:
Name  Type  Description 


number  given number 
Returns:
hyperbolic cosine of
x
 Type
 number
math_exp(x
) → {number}
computes the exponential function of
x
(e raised to the power of x
, where e is the base of the natural logarithms).
Parameters:
Name  Type  Description 


number  given number 
Returns:
e to the power of
x
 Type
 number
math_expm1(x
) → {number}
computes subtracting 1 from the
exponential function of
x
(e raised to the power of x
, where e is the base of
the natural logarithms). The result is computed in a way that is accurate even
when the value of x
is close to 0.
Parameters:
Name  Type  Description 


number  given number 
Returns:
1 plus e to the power of
x
 Type
 number
math_floor(x
) → {number}
computes the greatest (closest to +∞) Number value that is not greater than
If
x
and is an integer.
If
x
is already an integer, the result is x
.
NOTE: The value of math_floor(x) is the same as the value of math_ceil(x).
Parameters:
Name  Type  Description 


number  given number 
Returns:
floor of
x
 Type
 number
math_fround(x
) → {number}
When math_fround is called with argument
x
, the following steps are taken:
 If
x
is NaN, return NaN.  If
x
is one of +0, 0, +∞, ∞, returnx
.  Let x32 be the result of converting
x
to a value in IEEE 7542008 binary32 format using roundTiesToEven mode.  Let x64 be the result of converting x32 to a value in IEEE 7542008 binary64 format.
 Return the ECMAScript Number value corresponding to x64.
Parameters:
Name  Type  Description 


number  given number 
Returns:
fround of
x
 Type
 number
math_hypot() → {number}
computes the square root
of the sum of squares of its arguments.
If no arguments are passed, the result is +0.
If no arguments are passed, the result is +0.
Parameters:
Name  Type  Description 

value1,value2,... 
number  given numbers 
Returns:
square root of sum of squares of arguments
 Type
 number
math_imul(x
, x
) → {number}
When math_imul is called with arguments
x
and y
,
the following steps are taken:
 Let a be ToUint32(x).
 Let b be ToUint32(y).
 Let product be (a × b) modulo 2^{32}.
 If product ≥ 2^{31}, return product  2^{32}; otherwise return product.
Parameters:
Name  Type  Description 


number  given first number 

number  given second number 
Returns:

x
imul y
 Type
 number
math_log(x
) → {number}
Computes the natural logarithm of
x
.
Parameters:
Name  Type  Description 


number  given number 
Returns:
 natural logarithm of
x
 Type
 number
math_log1p(x
) → {number}
computes the natural logarithm of 1 +
x
. The result is computed in a way that is accurate even when the value of x
is close to zero.
Parameters:
Name  Type  Description 


number  given number 
Returns:
math_log(1 + x)
 Type
 number
math_log2(x
) → {number}
computes the base 2 logarithm of
x
.
Parameters:
Name  Type  Description 


number  given number 
Returns:
base 2 logarithm of
x
 Type
 number
math_log10(x
) → {number}
computes the base 10 logarithm of
x
.
Parameters:
Name  Type  Description 


number  given number 
Returns:
base 10 logarithm of
x
 Type
 number
math_max() → {number}
Given zero or more numbers, returns the largest of them.
If no arguments are given, the result is ∞.
If any value is NaN, the result is NaN. The comparison of values to determine the largest value is done using the Abstract Relational Comparison algorithm except that +0 is considered to be larger than 0.
If no arguments are given, the result is ∞.
If any value is NaN, the result is NaN. The comparison of values to determine the largest value is done using the Abstract Relational Comparison algorithm except that +0 is considered to be larger than 0.
Parameters:
Name  Type  Description 

value1,value2,... 
number  given numbers 
Returns:
largest of them
 Type
 number
math_min() → {number}
Given zero or more arguments, returns the smallest of them.
If no arguments are given, the result is +∞.
If any value is NaN, the result is NaN. The comparison of values to determine the smallest value is done using the Abstract Relational Comparison algorithm except that +0 is considered to be larger than 0.
If no arguments are given, the result is +∞.
If any value is NaN, the result is NaN. The comparison of values to determine the smallest value is done using the Abstract Relational Comparison algorithm except that +0 is considered to be larger than 0.
Parameters:
Name  Type  Description 

value1,value2,... 
number  given numbers 
Returns:
smallest of them
 Type
 number
math_pow(base, exponent) → {number}
Computes the result of raising base to
the power of exponent.
Parameters:
Name  Type  Description 

base 
number  the given base 
exponent 
number  the given exponent 
Returns:
base
to the power of exponent
 Type
 number
math_random() → {number}
Returns a number value with positive sign, greater than or equal to 0 but less than 1,
chosen randomly or pseudo randomly with approximately uniform distribution over that
range, using an implementationdependent algorithm or strategy. This function takes no arguments.
Each math_random function created for distinct realms must produce a distinct sequence
of values from successive calls.
Returns:
random number greater than or equal to 0 but less than 1
 Type
 number
math_round(x
) → {number}
Returns the number value that is closest to
If two integers are equally close to
x
and is an integer.
If two integers are equally close to
x
, then the result is the Number value
that is closer to +∞. If x
is already an integer, the result is x
.
NOTE 1:
math_round(3.5) returns 4, but math_round(3.5) returns 3.
Parameters:
Name  Type  Description 


number  the given number 
Returns:
closest integer to
x
 Type
 number
math_sign(x
) → {number}
Computes the sign of
x
, indicating whether x
is positive, negative, or zero.
Parameters:
Name  Type  Description 


number  the given number 
Returns:
the sign (1, 0 or +1)
 Type
 number
math_sin(x
) → {number}
Computes the sine of
x
.
The argument is expressed in radians.
Parameters:
Name  Type  Description 


number  the given number 
Returns:
the sine of
x
 Type
 number
math_sinh(x
) → {number}
Computes the hyperbolic sine of
x
.
NOTE: The value of sinh(x) is the same as (exp(x)  exp(x)) / 2.
Parameters:
Name  Type  Description 


number  the given number 
Returns:
the hyperbolic sine of
x
 Type
 number
math_sqrt(x
) → {number}
Computes the square root of
x
.
Parameters:
Name  Type  Description 


number  the given number 
Returns:
the square root of
x
 Type
 number
math_tan(x
) → {number}
Computes the tangent of
x
. The argument is expressed in radians.
Parameters:
Name  Type  Description 


number  the given number 
Returns:
the tangent of
x
 Type
 number
math_tanh(x
) → {number}
Computes the hyperbolic tangent of
x
.
NOTE:
The value of math_tanh(x)
is the same as
(exp(x)  exp(x))/(exp(x) + exp(x))
.
Parameters:
Name  Type  Description 


number  the given number 
Returns:
the hyperbolic tangent of
x
 Type
 number
math_trunc(x
) → {number}
Computes the integral part of the number
x
,
removing any fractional digits.
Parameters:
Name  Type  Description 


number  the given number 
Returns:
the integral part of
x
 Type
 number
member(v, xs) → {list}
Returns first postfix sublist
whose head is identical to
v
(using ===
); returns null
if the
element does not occur in the list.
Iterative process; time: Theta(n)
,
space: Theta(1)
, where n
is the length of xs
.
Parameters:
Name  Type  Description 

v 
value  given value 
xs 
list  given list 
Returns:
postfix sublist that starts with
v
 Type
 list
pair(x, y) → {pair}
**primitive**; makes a pair whose head (first component) is
x
and whose tail (second component) is y
; time: Theta(1)Theta(1)
.
Parameters:
Name  Type  Description 

x 
value  given head 
y 
value  given tail 
Returns:
pair with
x
as head and y
as tail.
 Type
 pair
parse_int(s, i) → {number}
Interprets a given string
Examples:
See ECMAScript Specification, Section 18.2.5 for details.
s
as an integer,
using the positive integer i
as radix,
and returns the respective value.
Examples:
parse_int("909", 10)
returns the number
909
, and parse_int("1111", 2)
returns the number
15
.See ECMAScript Specification, Section 18.2.5 for details.
Parameters:
Name  Type  Description 

s 
string  string to be converted 
i 
number  radix 
Returns:
result of conversion
 Type
 number
prompt(s) → {string}
Pops up a window that displays the string
s
, provides
an input line for the user to enter a text, a Cancel
button and an OK
button.
The call of prompt
suspends execution of the program until one of the two buttons is pressed. If
the OK
button is pressed, prompt
returns the entered text as a string.
If the Cancel
button is pressed, prompt
returns a nonstring value.
Parameters:
Name  Type  Description 

s 
string  to be displayed in popup 
Returns:
entered text
 Type
 string
remove(v, xs) → {list}
Returns a list that results from
xs
by removing the first item from xs
that
is identical (===
) to v
.
Returns the original
list if there is no occurrence. Iterative process;
time: Theta(n)
, space: Theta(n)
, where n
is the length of xs
.
Parameters:
Name  Type  Description 

v 
value  given value 
xs 
list  given list 
Returns:
xs
with first occurrence of v
removed
 Type
 list
remove_all(v, xs) → {list}
Returns a list that results from
xs
by removing all items from xs
that
are identical (===
) to v
.
Returns the original
list if there is no occurrence.
Iterative process;
time: Theta(n)
, space: Theta(n)
, where n
is the length of xs
.
Parameters:
Name  Type  Description 

v 
value  given value 
xs 
list  given list 
Returns:
xs
with all occurrences of v
removed
 Type
 list
reverse(xs) → {list}
Returns list
xs
in reverse
order. Iterative process; time: Theta(n)
,
space: Theta(n)
, where n
is the length of xs
.
The process is iterative, but consumes space Theta(n)
because of the result list.
Parameters:
Name  Type  Description 

xs 
list  given list 
Returns:
xs
in reverse
 Type
 list
set_head(p, x) → {undefined}
changes the pair
p
such that its head is x
.
Parameters:
Name  Type  Description 

p 
pair  given pair 
x 
value  given value 
Returns:
undefined
 Type
 undefined
set_tail(p, x) → {undefined}
changes the pair
p
such that its tail is x
.
Parameters:
Name  Type  Description 

p 
pair  given pair 
x 
value  given value 
Returns:
undefined
 Type
 undefined
stream() → {stream}
Given
n
values, returns a stream of length n
.
The elements of the stream are the given values in the given order.
Lazy? No: A
complete list is generated,
and then a stream using list_to_stream
is generated from it.
Parameters:
Name  Type  Description 

value1,value2,...,value_n 
value  given values 
Returns:
stream containing all values
 Type
 stream
stream_append(xs, ys) → {stream}
Returns a stream that results from
appending the stream
ys
to the stream xs
.
In the result, null at the end of the first argument stream
is replaced by the second argument, regardless what the second
argument consists of.
Lazy? Yes: the result stream forces the actual append operation
Parameters:
Name  Type  Description 

xs 
stream  given first stream 
ys 
stream  given second stream 
Returns:
result of appending
xs
and ys
 Type
 stream
stream_filter(pred, xs) → {stream}
Returns a stream that contains
only those elements of given stream
xs
for which the oneargument function
pred
returns true
.
Lazy? Yes: The result stream forces the construction of
each next element. Of course, the construction
of the next element needs to go down the stream
until an element is found for which pred
holds.
Parameters:
Name  Type  Description 

pred 
function  unary function returning boolean value 
xs 
stream  given stream 
Returns:
stream with those elements of
xs
for which pred
holds.
 Type
 stream
stream_for_each(f, xs) → {boolean}
Applies unary function
f
to every
element of the stream xs
.
Iterative process.
f
is applied elementbyelement:
stream_for_each(f, stream(1, 2))
results in the calls
f(1)
and f(2)
.
Lazy? No: stream_for_each
forces the exploration of the entire stream
Parameters:
Name  Type  Description 

f 
function  unary 
xs 
stream  given stream 
Returns:
true
 Type
 boolean
stream_length(xs) → {number}
Returns the length of the stream
xs
.
Iterative process.
Lazy? No: The function needs to explore the whole stream
Parameters:
Name  Type  Description 

xs 
stream  given stream 
Returns:
length of
xs
 Type
 number
stream_map(f, xs) → {stream}
Returns a stream that results from stream
xs
by elementwise application
of unary function f
.
f
is applied elementbyelement:
stream_map(f, stream(1,2))
results in
the same as stream(f(1),f(2))
.
Lazy? Yes: The argument stream is only explored as forced by
the result stream.
Parameters:
Name  Type  Description 

f 
function  unary 
xs 
stream  given stream 
Returns:
result of mapping
 Type
 stream
stream_member(v, xs) → {stream}
Returns first postfix substream
whose head is identical to
v
(using ===
); returns null
if the
element does not occur in the stream.
Iterative process.
Lazy? Sortof: stream_member
forces the stream only until the element
is found.
Parameters:
Name  Type  Description 

v 
value  given value 
xs 
stream  given stream 
Returns:
postfix substream that starts with
v
 Type
 stream
stream_ref(xs, n) → {value}
Returns the element
of stream
xs
at position n
,
where the first element has index 0.
Iterative process.
Lazy? Sortof: stream_ref
only forces the computation of
the first n
elements, and leaves the rest of
the stream untouched.
Parameters:
Name  Type  Description 

xs 
stream  given stream 
n 
number  given position 
Returns:
item in
xs
at position n
 Type
 value
stream_remove(v, xs) → {stream}
Returns a stream that results from
xs
by removing the first item from xs
that
is identical (===
) to v
.
Returns the original
stream if there is no occurrence.
Lazy? Yes: the result stream forces the construction of each next element
Parameters:
Name  Type  Description 

v 
value  given value 
xs 
stream  given stream 
Returns:
xs
with first occurrence of v
removed
 Type
 stream
stream_remove_all(v, xs) → {stream}
Returns a stream that results from
xs
by removing all items from xs
that
are identical (===
) to v
.
Returns the original
stream if there is no occurrence.
Recursive process.
Lazy? Yes: the result stream forces the construction of each next
element
Parameters:
Name  Type  Description 

v 
value  given value 
xs 
stream  given stream 
Returns:
xs
with all occurrences of v
removed
 Type
 stream
stream_reverse(xs) → {stream}
Returns stream
xs
in reverse
order. Iterative process.
The process is iterative, but consumes space Omega(n)
because of the result stream.
Lazy? No: stream_reverse
forces the exploration of the entire stream
Parameters:
Name  Type  Description 

xs 
stream  given stream 
Returns:
xs
in reverse
 Type
 stream
stream_tail(xs) → {Stream}
assumes that the tail (second component) of the
pair {x} is a nullary function, and returns the result of
applying that function. Throws an exception if the argument
is not a pair, or if the tail is not a function.
Laziness: Yes: {stream_tail} only forces the direct tail
stream, but not the rest of the stream, i.e. not the tail
of the tail, etc.
Parameters:
Name  Type  Description 

xs 
Stream  given stream 
Returns:
result stream (if stream discipline is used)
 Type
 Stream
stream_to_list(xs) → {list}
Given stream
xs
, returns a list of same length with
the same elements as xs
in the same order.
Laziness: No: stream_to_list
needs to force the whole
stream.
Parameters:
Name  Type  Description 

xs 
stream  stream 
Returns:
containing all elements of
xs
 Type
 list
stringify(v) → {string}
returns a string that represents the value
v
, using a
notation that is is consistent with
JSON,
but also displays undefined
, NaN
, Infinity
, and function objects.
See also textbook example.
Parameters:
Name  Type  Description 

v 
value  the argument value 
Returns:
string representation of v
 Type
 string
tail(p) → {value}
**primitive**; returns tail (second component of given pair
p
; time: Theta(1)Theta(1)
.
Parameters:
Name  Type  Description 

p 
pair  given pair 
Returns:
tail of
p
 Type
 value