source_3/global.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Predeclared in Source §3</title>
    <link rel="shortcut icon"
	  type="image/x-icon"
	  href="/images/sourcepower.ico" />
    <script src="scripts/prettify/prettify.js"> </script>
    <script src="scripts/prettify/lang-css.js"> </script>
    <!--[if lt IE 9]>
      <script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
    <![endif]-->
    <link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css">
    <link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css">
</head>

<body>

<div id="main">

    <h1 class="page-title">Predeclared in <a href=".">Source §3</a></h1>

    <!-- changed by MH on 1/7/2019 from default template. See "MH" below -->
<!-- changed by MH on 3/6/2021 from default template. See "MH" below -->


<section>

<header>
    
        <h2></h2>
        
    
</header>

<article>
    <div class="container-overview">
    
        
<dl class="details">

    
</dl>


    </div>

    
        <h3 class="subsection-title">Constants</h3> <!-- changed from >Members< by MH -->

        
            <div class="constant-entry">
                
<h4 class="name" id="Infinity"><span class="type-signature">(constant) </span>Infinity<span class="type-signature"> :number</span></h4>


<div class="description">
    The name <CODE>Infinity</CODE> refers to the special number value <CODE>Infinity</CODE>.
See <a href="https://www.ecma-international.org/ecma-262/9.0/index.html#sec-value-properties-of-the-global-object-infinity">ECMAScript Specification, Section 4.3.23</a>
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type">number</span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
            <div class="constant-entry">
                
<h4 class="name" id="math_E"><span class="type-signature">(constant) </span>math_E<span class="type-signature"> :number</span></h4>


<div class="description">
    The Number value for e, Euler's number,
which is approximately 2.718281828459045.
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type">number</span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
            <div class="constant-entry">
                
<h4 class="name" id="math_LN2"><span class="type-signature">(constant) </span>math_LN2<span class="type-signature"> :number</span></h4>


<div class="description">
    The Number value for the natural logarithm of 2,
which is approximately 0.6931471805599453.
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type">number</span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
            <div class="constant-entry">
                
<h4 class="name" id="math_LN10"><span class="type-signature">(constant) </span>math_LN10<span class="type-signature"> :number</span></h4>


<div class="description">
    The Number value for the natural logarithm of 10,
which is approximately 2.302585092994046.
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type">number</span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
            <div class="constant-entry">
                
<h4 class="name" id="math_LOG2E"><span class="type-signature">(constant) </span>math_LOG2E<span class="type-signature"> :number</span></h4>


<div class="description">
    The Number value for the base-2 logarithm of eℝ, the base of the natural logarithms; 
this value is approximately 1.4426950408889634.

<P/>NOTE:
The value of math_LOG2E is approximately the reciprocal of the value of math_LN2.
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type">number</span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
            <div class="constant-entry">
                
<h4 class="name" id="math_LOG10E"><span class="type-signature">(constant) </span>math_LOG10E<span class="type-signature"> :number</span></h4>


<div class="description">
    The Number value for the base-10 logarithm of e, 
the base of the natural logarithms; this value is approximately 0.4342944819032518.

<P/>NOTE:
The value of math_LOG10E is approximately the reciprocal of the value of math_LN10.
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type">number</span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
            <div class="constant-entry">
                
<h4 class="name" id="math_PI"><span class="type-signature">(constant) </span>math_PI<span class="type-signature"> :number</span></h4>


<div class="description">
    The Number value for π, the ratio of the circumference of a circle to its diameter, 
which is approximately 3.1415926535897932.
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type">number</span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
            <div class="constant-entry">
                
<h4 class="name" id="math_SQRT1_2"><span class="type-signature">(constant) </span>math_SQRT1_2<span class="type-signature"> :number</span></h4>


<div class="description">
    The Number value for the square root of 0.5, which is approximately 0.7071067811865476.

<P/>NOTE:
The value of math_SQRT1_2 is approximately the reciprocal of the value of math_SQRT2.
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type">number</span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
            <div class="constant-entry">
                
<h4 class="name" id="math_SQRT2"><span class="type-signature">(constant) </span>math_SQRT2<span class="type-signature"> :number</span></h4>


<div class="description">
    The Number value for the square root of 2, which is approximately 1.4142135623730951.
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type">number</span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
            <div class="constant-entry">
                
<h4 class="name" id="NaN"><span class="type-signature">(constant) </span>NaN<span class="type-signature"> :number</span></h4>


<div class="description">
    The name <CODE>NaN</CODE> refers to the special number value <CODE>NaN</CODE> ("not a number"). Note that
<CODE>NaN</CODE> is a number, as specified by <CODE>is_number</CODE>.
See <a href="https://www.ecma-international.org/ecma-262/9.0/index.html#sec-value-properties-of-the-global-object-nan">ECMAScript Specification, Section 4.3.24</a>
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type">number</span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
            <div class="constant-entry">
                
<h4 class="name" id="undefined"><span class="type-signature">(constant) </span>undefined<span class="type-signature"> :<a href="global.html#undefined">undefined</a></span></h4>


<div class="description">
    The name <CODE>undefined</CODE> refers to the special value <CODE>undefined</CODE>.
See also <a href="https://sourceacademy.org/sicpjs/4.1.1#h5">textbook explanation in section 4.1.1</a>.
</div>


    <h5>Type:</h5>
    <ul>
        <li>
            
<span class="param-type"><a href="global.html#undefined">undefined</a></span>


        </li>
    </ul>


<dl class="details">

    
</dl>


            </div>
        
    
        <h3 class="subsection-title">Functions</h3>  <!-- changed by MH on 1/7/2019, was Methods -->

        
            <div class="function-entry">
                

    <h4 class="name" id="__access_export__"><span class="type-signature"></span>__access_export__<span class="signature">(exports, lookup_name)</span><span class="type-signature"> &rarr; {value}</span></h4>
    

<div class="description">
    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, <code>undefined</code> is returned.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>exports</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#pair">pair</a></span>


            </td>

            
            <td class="description last">The data structure of exported values</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>lookup_name</code></td>
            

            <td class="type">
            
                
<span class="param-type">string</span>


            </td>

            
            <td class="description last">Name to import</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    The value corresponding to the imported name
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">value</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="__access_named_export__"><span class="type-signature"></span>__access_named_export__<span class="signature">(named_exports, lookup_name)</span><span class="type-signature"> &rarr; {value}</span></h4>
    

<div class="description">
    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,
<code>undefined</code> is returned.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>named_exports</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">The data structure of exported names</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>lookup_name</code></td>
            

            <td class="type">
            
                
<span class="param-type">string</span>


            </td>

            
            <td class="description last">Name to import</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    The value corresponding to the imported name
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">value</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="accumulate"><span class="type-signature"></span>accumulate<span class="signature">(f, initial, xs)</span><span class="type-signature"> &rarr; {value}</span></h4>
    

<div class="description">
    Applies binary
function <CODE>f</CODE> to the elements of <CODE>xs</CODE> from
right-to-left order, first applying <CODE>f</CODE> to the last element
and the value <CODE>initial</CODE>, resulting in <CODE>r</CODE><SUB>1</SUB>,
then to the
second-last element and <CODE>r</CODE><SUB>1</SUB>, resulting in
<CODE>r</CODE><SUB>2</SUB>,
etc, and finally
to the first element and <CODE>r</CODE><SUB>n-1</SUB>, where
<CODE>n</CODE> is the length of the
list. Thus, <CODE>accumulate(f,zero,list(1,2,3))</CODE> results in
<CODE>f(1, f(2, f(3, zero)))</CODE>.
Iterative process;
time: <CODE>Theta(n)</CODE> (apart from <CODE>f</CODE>), space: <CODE>Theta(n)</CODE> (apart from <CODE>f</CODE>),
where <CODE>n</CODE> is the length of <CODE>xs</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>f</code></td>
            

            <td class="type">
            
                
<span class="param-type">function</span>


            </td>

            
            <td class="description last">binary function</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>initial</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">initial value</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    result of accumulating <CODE>xs</CODE> using <CODE>f</CODE> starting with <CODE>initial</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">value</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="append"><span class="type-signature"></span>append<span class="signature">(xs, ys)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Returns a list that results from
appending the list <CODE>ys</CODE> to the list <CODE>xs</CODE>.
Iterative process; time: <CODE>Theta(n)</CODE>, space:
<CODE>Theta(n)</CODE>, where <CODE>n</CODE> is the length of <CODE>xs</CODE>.
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.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given first list</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>ys</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given second list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    result of appending <CODE>xs</CODE> and <CODE>ys</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="arity"><span class="type-signature"></span>arity<span class="signature">(f)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Returns the number of parameters the given function <CODE>f</CODE> expects,
excluding the rest parameter.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>f</code></td>
            

            <td class="type">
            
                
<span class="param-type">function</span>


            </td>

            
            <td class="description last">given function</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    number of parameters f expects
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="array_length"><span class="type-signature"></span>array_length<span class="signature">(x)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    **primitive**; returns
the current length of array <CODE>x</CODE>, which is 1 plus the
highest index that has been used so far in an array assignment on
<CODE>x</CODE>. Here literal array expressions are counted too: The
array <CODE>[10, 20, 30]</CODE> has a length of 3.
Time: <CODE>Θ(1)</CODE>, space: <CODE>Θ(1)</CODE>
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>x</code></td>
            

            <td class="type">
            
                
<span class="param-type">array</span>


            </td>

            
            <td class="description last">given array</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    current length of array
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="build_list"><span class="type-signature"></span>build_list<span class="signature">(f, n)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Makes a list with <CODE>n</CODE>
elements by applying the unary function <CODE>f</CODE>
to the numbers 0 to <CODE>n - 1</CODE>, assumed to be a nonnegative integer.
Iterative process; time: <CODE>Theta(n)</CODE> (apart from <CODE>f</CODE>), space: <CODE>Theta(n)</CODE> (apart from <CODE>f</CODE>).
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>f</code></td>
            

            <td class="type">
            
                
<span class="param-type">function</span>


            </td>

            
            <td class="description last">unary function</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>n</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given nonnegative integer</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    resulting list
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="build_stream"><span class="type-signature"></span>build_stream<span class="signature">(f, n)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Makes a stream with <CODE>n</CODE>
elements by applying the unary function <CODE>f</CODE>
to the numbers 0 to <CODE>n - 1</CODE>, assumed to be a nonnegative integer.
Lazy? Yes: The result stream forces the application of <CODE>f</CODE>
          for the next element
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>f</code></td>
            

            <td class="type">
            
                
<span class="param-type">function</span>


            </td>

            
            <td class="description last">unary function</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>n</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given nonnegative integer</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    resulting stream
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="char_at"><span class="type-signature"></span>char_at<span class="signature">(s, i)</span><span class="type-signature"> &rarr; {string}</span></h4>
    

<div class="description">
    Takes a string <CODE>s</CODE> as first argument and a nonnegative integer
<CODE>i</CODE> as second argument. If <CODE>i</CODE> is less than the length
of <CODE>s</CODE>, this function returns a one-character string that contains
the character of <CODE>s</CODE> at position <CODE>i</CODE>, counting from 0.
If <CODE>i</CODE> is larger than or equal to the length of
<CODE>s</CODE>, this function returns <CODE>undefined</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>s</code></td>
            

            <td class="type">
            
                
<span class="param-type">string</span>


            </td>

            
            <td class="description last">given string</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>i</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">index</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    one-character or undefined
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">string</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="display"><span class="type-signature"></span>display<span class="signature">(v, s)</span><span class="type-signature"> &rarr; {value}</span></h4>
    

<div class="description">
    Optional second argument. If present,
displays the given string <CODE>s</CODE>, followed by a space character, followed by the
value <CODE>v</CODE> in the console.
If second argument not present,
just displays the value <CODE>v</CODE> in the console.
The notation used for the display of values
is consistent with
<a href="http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf">JSON</a>,
but also displays <CODE>undefined</CODE>, <CODE>NaN</CODE>, <CODE>Infinity</CODE>, and function objects.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">to be displayed</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>s</code></td>
            

            <td class="type">
            
                
<span class="param-type">string</span>


            </td>

            
            <td class="description last">to be displayed, preceding <CODE>v</CODE>, optional argument</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    v, the first argument value
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">value</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="display_list"><span class="type-signature"></span>display_list<span class="signature">(xs, s)</span><span class="type-signature"> &rarr; {value}</span></h4>
    

<div class="description">
    Optional second argument.
Similar to <CODE>display</CODE>, but formats well-formed lists nicely if detected;
time, space:
<CODE>Theta(n)</CODE>, where <CODE>n</CODE> is the total number of data structures such as
pairs in <CODE>x</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">list structure to be displayed</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>s</code></td>
            

            <td class="type">
            
                
<span class="param-type">string</span>


            </td>

            
            <td class="description last">to be displayed, preceding <CODE>xs</CODE></td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    xs, the first argument value
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">value</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="draw_data"><span class="type-signature"></span>draw_data<span class="signature">()</span><span class="type-signature"> &rarr; {value}</span></h4>
    

<div class="description">
    visualizes the arguments in a separate drawing
area in the Source Academy using box-and-pointer diagrams; time, space:
<CODE>Theta(n)</CODE>, where <CODE>n</CODE> is the total number of data structures such as
pairs in the arguments.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>value1,value2,...,value_n</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given values</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    given <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">value</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="enum_list"><span class="type-signature"></span>enum_list<span class="signature">(start, end)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Returns a list that enumerates
numbers starting from <CODE>start</CODE> using a step size of 1, until
the number exceeds (<CODE>&gt;</CODE>) <CODE>end</CODE>.
Iterative process;
time: <CODE>Theta(n)</CODE>, space: <CODE>Theta(n)</CODE>,
where <CODE>n</CODE> is <CODE>end - start</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>start</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">starting number</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>end</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">ending number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    list from <CODE>start</CODE> to <CODE>end</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="enum_stream"><span class="type-signature"></span>enum_stream<span class="signature">(start, end)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Returns a stream that enumerates
numbers starting from <CODE>start</CODE> using a step size of 1, until
the number exceeds (<CODE>&gt;</CODE>) <CODE>end</CODE>.
Lazy? Yes: The result stream forces the construction of
           each next element
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>start</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">starting number</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>end</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">ending number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    stream from <CODE>start</CODE> to <CODE>end</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="equal"><span class="type-signature"></span>equal<span class="signature">(x, y)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    Returns <CODE>true</CODE> if both
have the same structure with respect to <CODE>pair</CODE>,
and identical values at corresponding leave positions (places that are not
themselves pairs), and <CODE>false</CODE> otherwise. For the "identical",
the values need to have the same type, otherwise the result is
<CODE>false</CODE>. If corresponding leaves are boolean values, these values
need to be the same. If both are <CODE>undefined</CODE> or both are
<CODE>null</CODE>, the result is <CODE>true</CODE>. Otherwise they are compared
with <CODE>===</CODE> (using the definition of <CODE>===</CODE> in the
respective Source language in use).
Time, space:
<CODE>Theta(n)</CODE>, where <CODE>n</CODE> is the total number of data structures such as
pairs in <CODE>x</CODE> and <CODE>y</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>x</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>y</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    whether <CODE>x</CODE> is structurally equal to <CODE>y</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="error"><span class="type-signature"></span>error<span class="signature">(v, s)</span><span class="type-signature"></span></h4>
    

<div class="description">
    Optional second argument.
If present,
displays the given string <CODE>s</CODE>, followed by a space character, followed by the
value <CODE>v</CODE> in the console with error flag.
If second argument not present,
just displays the value <CODE>v</CODE> in the console with error flag.
The evaluation
of any call of <CODE>error</CODE> aborts the running program immediately.
The notation used for the display of values
is consistent with
<a href="http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf">JSON</a>,
but also displays <CODE>undefined</CODE>, <CODE>NaN</CODE>, <CODE>Infinity</CODE>, and function objects.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">to be displayed</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>s</code></td>
            

            <td class="type">
            
                
<span class="param-type">string</span>


            </td>

            
            <td class="description last">to be displayed, preceding <CODE>v</CODE></td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="eval_stream"><span class="type-signature"></span>eval_stream<span class="signature">(s, n)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Constructs the list of the first <CODE>n</CODE> elements
of a given stream <CODE>s</CODE>
Lazy? Sort-of: <CODE>eval_stream</CODE> only forces the computation of
the first <CODE>n</CODE> elements, and leaves the rest of
the stream untouched.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>s</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>n</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">nonnegative number of elements to place in result list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    result list
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="filter"><span class="type-signature"></span>filter<span class="signature">(pred, xs)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Returns a list that contains
only those elements for which the one-argument function
<CODE>pred</CODE>
returns <CODE>true</CODE>.
Iterative process;
time: <CODE>Theta(n)</CODE> (apart from <CODE>pred</CODE>), space: <CODE>Theta(n)</CODE> (apart from <CODE>pred</CODE>),
where <CODE>n</CODE> is the length of <CODE>xs</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>pred</code></td>
            

            <td class="type">
            
                
<span class="param-type">function</span>


            </td>

            
            <td class="description last">unary function returning boolean value</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    list with those elements of <CODE>xs</CODE> for which <CODE>pred</CODE> holds.
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="for_each"><span class="type-signature"></span>for_each<span class="signature">(f, xs)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    Applies unary function <CODE>f</CODE> to every
element of the list <CODE>xs</CODE>.
Iterative process; time: <CODE>Theta(n)</CODE> (apart from <CODE>f</CODE>), space: <CODE>Theta(1)</CODE> (apart from <CODE>f</CODE>),
where <CODE>n</CODE> is the length of <CODE>xs</CODE>.
<CODE>f</CODE> is applied element-by-element:
<CODE>for_each(fun, list(1, 2))</CODE> results in the calls
<CODE>fun(1)</CODE> and <CODE>fun(2)</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>f</code></td>
            

            <td class="type">
            
                
<span class="param-type">function</span>


            </td>

            
            <td class="description last">unary</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    true
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="get_time"><span class="type-signature"></span>get_time<span class="signature">()</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Returns number of milliseconds elapsed since January 1, 1970 00:00:00 UTC.
See also <a href="https://sourceacademy.org/sicpjs/1.2.6#ex-1.21">textbook example</a>.
</div>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    current time in milliseconds
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="head"><span class="type-signature"></span>head<span class="signature">(p)</span><span class="type-signature"> &rarr; {value}</span></h4>
    

<div class="description">
    **primitive**; returns head (first component) of given pair <CODE>p</CODE>; time: <CODE>Theta(1)</CODE, space: <CODE>Theta(1)</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>p</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#pair">pair</a></span>


            </td>

            
            <td class="description last">given pair</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    head of <CODE>p</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">value</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="integers_from"><span class="type-signature"></span>integers_from<span class="signature">(start)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Returns infinite stream if integers starting
at given number <CODE>n</CODE> using a step size of 1.
Lazy? Yes: The result stream forces the construction of
           each next element
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>start</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">starting number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    infinite stream from <CODE>n</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="is_array"><span class="type-signature"></span>is_array<span class="signature">(x)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    **primitive**; returns <CODE>true</CODE> if <CODE>x</CODE>
is an array, and <CODE>false</CODE> if it is not.
Time: <CODE>Θ(1)</CODE>, space: <CODE>Θ(1)</CODE>
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>x</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    whether <CODE>x</CODE> is an array
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="is_boolean"><span class="type-signature"></span>is_boolean<span class="signature">(v)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    checks whether a given value is a boolean
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">to be checked</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    indicating whether the value is a boolean
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="is_function"><span class="type-signature"></span>is_function<span class="signature">(v)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    checks whether a given value is a function
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">to be checked</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    indicating whether the value is a function
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="is_list"><span class="type-signature"></span>is_list<span class="signature">(xs)</span><span class="type-signature"> &rarr; {xs}</span></h4>
    

<div class="description">
    **primitive**; returns <CODE>true</CODE> if
<CODE>xs</CODE> is a list as defined in the textbook, and
<CODE>false</CODE> otherwise. Iterative process;
time: <CODE>Theta(n)</CODE>, space: <CODE>Theta(1)</CODE>, where <CODE>n</CODE>
is the length of the
chain of <CODE>tail</CODE> operations that can be applied to <CODE>xs</CODE>.
<CODE>is_list</CODE> recurses down the list and checks that it ends with the empty list null
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given candidate</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    whether  is a list
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">xs</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="is_null"><span class="type-signature"></span>is_null<span class="signature">(x)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    **primitive**; returns <CODE>true</CODE> if <CODE>x</CODE> is the
empty list <CODE>null</CODE>, and <CODE>false</CODE> otherwise; time: <CODE>Theta(1)</CODE, space: <CODE>Theta(1)</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>x</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    whether <CODE>x</CODE> is <CODE>null</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="is_number"><span class="type-signature"></span>is_number<span class="signature">(v)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    checks whether a given value is a number.
See also <a href="https://sourceacademy.org/sicpjs/2.3.2">textbook example</a>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">to be checked</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    indicating whether the value is a number
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="is_pair"><span class="type-signature"></span>is_pair<span class="signature">(x)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    **primitive**; returns <CODE>true</CODE> if <CODE>x</CODE> is a
pair and false otherwise; time: <CODE>Theta(1)</CODE, space: <CODE>Theta(1)</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>x</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    whether <CODE>x</CODE> is a pair
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="is_stream"><span class="type-signature"></span>is_stream<span class="signature">(xs)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    Returns <CODE>true</CODE> if
<CODE>xs</CODE> is a stream as defined in the textbook, and
<CODE>false</CODE> otherwise. Iterative process.
Recurses down the stream and checks that it ends with the empty stream null.
Laziness:  No: <CODE>is_stream</CODE> needs to force the given stream.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given candidate</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    whether <CODE>xs</CODE> is a stream
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="is_string"><span class="type-signature"></span>is_string<span class="signature">(v)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    checks whether a given value is a string.
See also <a href="https://sourceacademy.org/sicpjs/2.3.2">textbook example</a>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">to be checked</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    indicating whether the value is a string
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="is_undefined"><span class="type-signature"></span>is_undefined<span class="signature">(v)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    checks whether a given value is the special value <CODE>undefined</CODE>
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">to be checked</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    indicating whether the value is <CODE>undefined</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="length"><span class="type-signature"></span>length<span class="signature">(xs)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Returns the length of the list
<CODE>xs</CODE>.
Iterative process; time: <CODE>Theta(n)</CODE>, space:
<CODE>Theta(1)</CODE>, where <CODE>n</CODE> is the length of <CODE>xs</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    length of <CODE>xs</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="list"><span class="type-signature"></span>list<span class="signature">()</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    **primitive**; given <CODE>n</CODE> values, returns a list of length <CODE>n</CODE>.
The elements of the list are the given values in the given order; time: <CODE>Theta(n)</CODE, space: <CODE>Theta(n)</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>value1,value2,...,value_n</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given values</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    list containing all values
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="list_ref"><span class="type-signature"></span>list_ref<span class="signature">(xs, n)</span><span class="type-signature"> &rarr; {value}</span></h4>
    

<div class="description">
    Returns the element
of list <CODE>xs</CODE> at position <CODE>n</CODE>,
where the first element has index 0.
Iterative process;
time: <CODE>Theta(n)</CODE>, space: <CODE>Theta(1)</CODE>,
where <CODE>n</CODE> is the length of <CODE>xs</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>n</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given position</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    item in <CODE>xs</CODE> at position <CODE>n</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">value</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="list_to_stream"><span class="type-signature"></span>list_to_stream<span class="signature">(xs)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Given list <CODE>xs</CODE>, returns a stream of same length with
the same elements as <CODE>xs</CODE> in the same order.
Laziness:  Yes: <CODE>list_to_stream</CODE>
goes down the list only when forced.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    stream containing all elements of <CODE>xs</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="list_to_string"><span class="type-signature"></span>list_to_string<span class="signature">(xs)</span><span class="type-signature"> &rarr; {string}</span></h4>
    

<div class="description">
    Returns a string that represents
list <CODE>xs</CODE> using the text-based box-and-pointer notation
<CODE>[...]</CODE>.
Iterative process; time: <CODE>Theta(n)</CODE> where <CODE>n</CODE> is the size of the list, space: <CODE>Theta(m)</CODE> where <CODE>m</CODE> is the length of the string.
The process is iterative, but consumes space <CODE>O(m)</CODE>
because of the result string.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    <CODE>xs</CODE> converted to string
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">string</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="map"><span class="type-signature"></span>map<span class="signature">(f, xs)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Returns a list that results from list
<CODE>xs</CODE> by element-wise application of unary function <CODE>f</CODE>.
Iterative process; time: <CODE>Theta(n)</CODE> (apart from <CODE>f</CODE>),
space: <CODE>Theta(n)</CODE> (apart from <CODE>f</CODE>), where <CODE>n</CODE> is the length of <CODE>xs</CODE>.
<CODE>f</CODE> is applied element-by-element:
<CODE>map(f, list(1, 2))</CODE> results in <CODE>list(f(1), f(2))</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>f</code></td>
            

            <td class="type">
            
                
<span class="param-type">function</span>


            </td>

            
            <td class="description last">unary</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    result of mapping
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_abs"><span class="type-signature"></span>math_abs<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the absolute value of x; the result has the same magnitude as <CODE>x</CODE> but has positive sign.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    absolute value of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_acos"><span class="type-signature"></span>math_acos<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the arc cosine of <CODE>x</CODE>.
The result is expressed in radians and ranges from +0 to +π.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    arc cosine of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_acosh"><span class="type-signature"></span>math_acosh<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the inverse hyperbolic cosine of <CODE>x</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    inverse hyperbolic cosine of <CODE>x</CODE>.
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_asin"><span class="type-signature"></span>math_asin<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the arc sine of <CODE>x</CODE>. The result is expressed in radians and ranges from -π / 2 to +π / 2.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    arc sine of <CODE>x</CODE>.
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_asinh"><span class="type-signature"></span>math_asinh<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the inverse hyperbolic
sine of <CODE>x</CODE>. The result is expressed in radians and ranges from -π / 2 to +π / 2.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    inverse hyperbolic sine of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_atan"><span class="type-signature"></span>math_atan<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the arc tangent of <CODE>x</CODE>. The result is expressed in radians and ranges from -π / 2 to +π / 2.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    arc tangent of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_atan2"><span class="type-signature"></span>math_atan2<span class="signature">(<CODE>y</CODE>, <CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the arc tangent of the quotient <CODE>y</CODE> / <CODE>x</CODE> of the arguments <CODE>y</CODE> and <CODE>x</CODE>, where the signs of <CODE>y</CODE> and <CODE>x</CODE> are used to determine the quadrant of the result. Note that it is intentional and traditional for the two-argument arc tangent function that the argument named <CODE>y</CODE> be first and the argument named <CODE>x</CODE> be second. The result is expressed in radians and ranges from -π to +π.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>y</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given first number</td>
        </tr>

    
        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given second number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    arc tangent of <CODE>y</CODE> / <CODE>x</CODE>.
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_atanh"><span class="type-signature"></span>math_atanh<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the inverse hyperbolic tangent of <CODE>x</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    inverse hyperbolic tangent of <CODE>x</CODE>.
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_cbrt"><span class="type-signature"></span>math_cbrt<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the cube root of <CODE>x</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    cube root of <CODE>x</CODE>.
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_ceil"><span class="type-signature"></span>math_ceil<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the smallest (closest to -∞) Number value that is not less than <CODE>x</CODE> and is an integer. If <CODE>x</CODE> is already an integer, the result is <CODE>x</CODE>.
The value of math_ceil(x) is the same as the value of -math_floor(-x).
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    "ceiling" of the number
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_clz32"><span class="type-signature"></span>math_clz32<span class="signature">(n)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    When math_clz32 is called with one argument <CODE>x</CODE>, the following steps are taken:

Let n be ToUint32(x).
Let p be the number of leading zero bits in the 32-bit binary representation of n.
Return p.

<P/>NOTE:
<BR/>If n is 0, p will be 32. If the most significant bit of the 32-bit binary encoding of n is 1,
p will be 0.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>n</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    p - leading zero bits
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_cos"><span class="type-signature"></span>math_cos<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Computes the cosine of <CODE>x</CODE>.
The argument is expressed in radians.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    - cosine of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_cosh"><span class="type-signature"></span>math_cosh<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the hyperbolic cosine of <CODE>x</CODE>.
<P/>NOTE:
The value of cosh(x) is the same as (exp(x) + exp(-x)) / 2.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    hyperbolic cosine of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_exp"><span class="type-signature"></span>math_exp<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the exponential function of <CODE>x</CODE>
(e raised to the power of <CODE>x</CODE>, where e is the base of the natural logarithms).
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    e to the power of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_expm1"><span class="type-signature"></span>math_expm1<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes subtracting 1 from the
exponential function of <CODE>x</CODE> (e raised to the power of <CODE>x</CODE>, where e is the base of
the natural logarithms). The result is computed in a way that is accurate even
when the value of <CODE>x</CODE> is close to 0.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    -1 plus e to the power of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_floor"><span class="type-signature"></span>math_floor<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the greatest (closest to +∞) Number value that is not greater than <CODE>x</CODE>
and is an integer.
<BR/>If <CODE>x</CODE> is already an integer, the result is <CODE>x</CODE>.

<P/>NOTE:
The value of math_floor(x) is the same as the value of -math_ceil(-x).
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    floor of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_fround"><span class="type-signature"></span>math_fround<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    When math_fround is called with argument <CODE>x</CODE>, the following steps are taken:

<OL><LI>If <CODE>x</CODE> is NaN, return NaN.</LI>
<LI>If <CODE>x</CODE> is one of +0, -0, +∞, -∞, return <CODE>x</CODE>.</LI>
<LI>Let x32 be the result of converting <CODE>x</CODE> to a value in IEEE 754-2008 binary32 format using roundTiesToEven mode.</LI>
<LI>Let x64 be the result of converting x32 to a value in IEEE 754-2008 binary64 format.</LI>
<LI>Return the ECMAScript Number value corresponding to x64.</LI></OL>
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    fround of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_hypot"><span class="type-signature"></span>math_hypot<span class="signature">()</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the square root
of the sum of squares of its arguments.

<BR/>If no arguments are passed, the result is +0.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>value1,value2,...</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given numbers</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    square root of sum of squares of arguments
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_imul"><span class="type-signature"></span>math_imul<span class="signature">(<CODE>x</CODE>, <CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    When math_imul is called with arguments <CODE>x</CODE> and <CODE>y</CODE>,
the following steps are taken:
<OL>
<LI>Let a be ToUint32(x).</LI>
<LI>Let b be ToUint32(y).</LI>
<LI>Let product be (a × b) modulo 2<SUP>32</SUP>.</LI>
<LI>If product ≥ 2<SUP>31</SUP>, return product - 2<SUP>32</SUP>; otherwise return product.</LI></OL>
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given first number</td>
        </tr>

    
        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given second number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    - <CODE>x</CODE> imul y
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_log"><span class="type-signature"></span>math_log<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Computes the natural logarithm of <CODE>x</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    - natural logarithm of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_log1p"><span class="type-signature"></span>math_log1p<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the natural logarithm of 1 + <CODE>x</CODE>. The result is computed in a way that is accurate even when the value of <CODE>x</CODE> is close to zero.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    math_log(1 + x)
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_log2"><span class="type-signature"></span>math_log2<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the base 2 logarithm of <CODE>x</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    base 2 logarithm of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_log10"><span class="type-signature"></span>math_log10<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    computes the base 10 logarithm of <CODE>x</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    base 10 logarithm of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_max"><span class="type-signature"></span>math_max<span class="signature">()</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Given zero or more numbers, returns the largest of them.

<BR/>If no arguments are given, the result is -∞.
<BR/>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.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>value1,value2,...</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given numbers</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    largest of them
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_min"><span class="type-signature"></span>math_min<span class="signature">()</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Given zero or more arguments, returns the smallest of them.

<BR/>If no arguments are given, the result is +∞.
<BR/>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.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>value1,value2,...</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given numbers</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    smallest of them
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_pow"><span class="type-signature"></span>math_pow<span class="signature">(base, exponent)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Computes the result of raising base to
the power of exponent.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>base</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">the given base</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>exponent</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">the given exponent</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    <CODE>base</CODE> to the power of <CODE>exponent</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_random"><span class="type-signature"></span>math_random<span class="signature">()</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    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 implementation-dependent 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.
</div>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    random number greater than or equal to 0 but less than 1
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_round"><span class="type-signature"></span>math_round<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Returns the number value that is closest to <CODE>x</CODE> and is an integer.
<BR/>If two integers are equally close to <CODE>x</CODE>, then the result is the Number value
that is closer to +∞. If <CODE>x</CODE> is already an integer, the result is <CODE>x</CODE>.

NOTE 1:
math_round(3.5) returns 4, but math_round(-3.5) returns -3.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">the given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    closest integer to <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_sign"><span class="type-signature"></span>math_sign<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Computes the sign of <CODE>x</CODE>, indicating whether <CODE>x</CODE> is positive, negative, or zero.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">the given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    the sign (-1, 0 or +1)
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_sin"><span class="type-signature"></span>math_sin<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Computes the sine of <CODE>x</CODE>.
The argument is expressed in radians.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">the given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    the sine of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_sinh"><span class="type-signature"></span>math_sinh<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Computes the hyperbolic sine of <CODE>x</CODE>.
<P/>NOTE:
The value of sinh(x) is the same as (exp(x) - exp(-x)) / 2.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">the given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    the hyperbolic sine of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_sqrt"><span class="type-signature"></span>math_sqrt<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Computes the square root of <CODE>x</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">the given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    the square root of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_tan"><span class="type-signature"></span>math_tan<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Computes the tangent of <CODE>x</CODE>. The argument is expressed in radians.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">the given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    the tangent of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_tanh"><span class="type-signature"></span>math_tanh<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Computes the hyperbolic tangent of <CODE>x</CODE>.

<P/>NOTE:
The value of <CODE>math_tanh(x)</CODE> is the same as
<CODE>(exp(x) - exp(-x))/(exp(x) + exp(-x))</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">the given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    the hyperbolic tangent of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="math_trunc"><span class="type-signature"></span>math_trunc<span class="signature">(<CODE>x</CODE>)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Computes the integral part of the number <CODE>x</CODE>,
removing any fractional digits.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code><CODE>x</CODE></code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">the given number</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    the integral part of <CODE>x</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="member"><span class="type-signature"></span>member<span class="signature">(v, xs)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Returns first postfix sublist
whose head is identical to
<CODE>v</CODE> (using <CODE>===</CODE>); returns <CODE>null</CODE> if the
element does not occur in the list.
Iterative process; time: <CODE>Theta(n)</CODE>,
space: <CODE>Theta(1)</CODE>, where <CODE>n</CODE> is the length of <CODE>xs</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    postfix sublist that starts with <CODE>v</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="pair"><span class="type-signature"></span>pair<span class="signature">(x, y)</span><span class="type-signature"> &rarr; {<a href="global.html#pair">pair</a>}</span></h4>
    

<div class="description">
    **primitive**; makes a pair whose head (first component) is <CODE>x</CODE>
and whose tail (second component) is <CODE>y</CODE>; time: <CODE>Theta(1)</CODE, space: <CODE>Theta(1)</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>x</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given head</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>y</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given tail</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    pair with <CODE>x</CODE> as head and <CODE>y</CODE> as tail.
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#pair">pair</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="parse_int"><span class="type-signature"></span>parse_int<span class="signature">(s, i)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Interprets a given string <CODE>s</CODE> as an integer,
using the positive integer <CODE>i</CODE> as radix,
and returns the respective value.
<BR/>Examples: <CODE>parse_int("909", 10)</CODE> returns the number
<CODE>909</CODE>, and <CODE>parse_int("-1111", 2)</CODE> returns the number
<CODE>-15</CODE>.<BR/>
See <a href="https://www.ecma-international.org/ecma-262/9.0/index.html#sec-parseint-string-radix">ECMAScript Specification, Section 18.2.5</a> for details.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>s</code></td>
            

            <td class="type">
            
                
<span class="param-type">string</span>


            </td>

            
            <td class="description last">string to be converted</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>i</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">radix</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    result of conversion
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="prompt"><span class="type-signature"></span>prompt<span class="signature">(s)</span><span class="type-signature"> &rarr; {string}</span></h4>
    

<div class="description">
    Pops up a window that displays the string <CODE>s</CODE>, provides
an input line for the user to enter a text, a <CODE>Cancel</CODE> button and an <CODE>OK</CODE> button.
The call of <CODE>prompt</CODE>
suspends execution of the program until one of the two buttons is pressed. If
the <CODE>OK</CODE> button is pressed, <CODE>prompt</CODE> returns the entered text as a string.
If the <CODE>Cancel</CODE> button is pressed, <CODE>prompt</CODE> returns a non-string value.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>s</code></td>
            

            <td class="type">
            
                
<span class="param-type">string</span>


            </td>

            
            <td class="description last">to be displayed in popup</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    entered text
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">string</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="remove"><span class="type-signature"></span>remove<span class="signature">(v, xs)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Returns a list that results from
<CODE>xs</CODE> by removing the first item from <CODE>xs</CODE> that
is identical (<CODE>===</CODE>) to <CODE>v</CODE>.
Returns the original
list if there is no occurrence. Iterative process;
time: <CODE>Theta(n)</CODE>, space: <CODE>Theta(n)</CODE>, where <CODE>n</CODE>
is the length of <CODE>xs</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    <CODE>xs</CODE> with first occurrence of <CODE>v</CODE> removed
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="remove_all"><span class="type-signature"></span>remove_all<span class="signature">(v, xs)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Returns a list that results from
<CODE>xs</CODE> by removing all items from <CODE>xs</CODE> that
are identical (<CODE>===</CODE>) to <CODE>v</CODE>.
Returns the original
list if there is no occurrence.
Iterative process;
time: <CODE>Theta(n)</CODE>, space: <CODE>Theta(n)</CODE>, where <CODE>n</CODE>
is the length of <CODE>xs</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    <CODE>xs</CODE> with all occurrences of <CODE>v</CODE> removed
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="reverse"><span class="type-signature"></span>reverse<span class="signature">(xs)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Returns list <CODE>xs</CODE> in reverse
order. Iterative process; time: <CODE>Theta(n)</CODE>,
space: <CODE>Theta(n)</CODE>, where <CODE>n</CODE> is the length of <CODE>xs</CODE>.
The process is iterative, but consumes space <CODE>Theta(n)</CODE>
because of the result list.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#list">list</a></span>


            </td>

            
            <td class="description last">given list</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    <CODE>xs</CODE> in reverse
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="set_head"><span class="type-signature"></span>set_head<span class="signature">(p, x)</span><span class="type-signature"> &rarr; {<a href="global.html#undefined">undefined</a>}</span></h4>
    

<div class="description">
    changes the pair <CODE>p</CODE> such that its head is <CODE>x</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>p</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#pair">pair</a></span>


            </td>

            
            <td class="description last">given pair</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>x</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    undefined
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#undefined">undefined</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="set_tail"><span class="type-signature"></span>set_tail<span class="signature">(p, x)</span><span class="type-signature"> &rarr; {<a href="global.html#undefined">undefined</a>}</span></h4>
    

<div class="description">
    changes the pair <CODE>p</CODE> such that its tail is <CODE>x</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>p</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#pair">pair</a></span>


            </td>

            
            <td class="description last">given pair</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>x</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    undefined
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#undefined">undefined</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream"><span class="type-signature"></span>stream<span class="signature">()</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Given <CODE>n</CODE> values, returns a stream of length <CODE>n</CODE>.
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 <CODE>list_to_stream</CODE> is generated from it.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>value1,value2,...,value_n</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given values</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    stream containing all values
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_append"><span class="type-signature"></span>stream_append<span class="signature">(xs, ys)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Returns a stream that results from
appending the stream <CODE>ys</CODE> to the stream <CODE>xs</CODE>.
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
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given first stream</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>ys</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given second stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    result of appending <CODE>xs</CODE> and <CODE>ys</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_filter"><span class="type-signature"></span>stream_filter<span class="signature">(pred, xs)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Returns a stream that contains
only those elements of given stream <CODE>xs</CODE>
for which the one-argument function
<CODE>pred</CODE>
returns <CODE>true</CODE>.
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 <CODE>pred</CODE> holds.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>pred</code></td>
            

            <td class="type">
            
                
<span class="param-type">function</span>


            </td>

            
            <td class="description last">unary function returning boolean value</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    stream with those elements of <CODE>xs</CODE> for which <CODE>pred</CODE> holds.
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_for_each"><span class="type-signature"></span>stream_for_each<span class="signature">(f, xs)</span><span class="type-signature"> &rarr; {boolean}</span></h4>
    

<div class="description">
    Applies unary function <CODE>f</CODE> to every
element of the stream <CODE>xs</CODE>.
Iterative process.
<CODE>f</CODE> is applied element-by-element:
<CODE>stream_for_each(f, stream(1, 2))</CODE> results in the calls
<CODE>f(1)</CODE> and <CODE>f(2)</CODE>.
Lazy? No: <CODE>stream_for_each</CODE>
forces the exploration of the entire stream
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>f</code></td>
            

            <td class="type">
            
                
<span class="param-type">function</span>


            </td>

            
            <td class="description last">unary</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    true
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">boolean</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_length"><span class="type-signature"></span>stream_length<span class="signature">(xs)</span><span class="type-signature"> &rarr; {number}</span></h4>
    

<div class="description">
    Returns the length of the stream
<CODE>xs</CODE>.
Iterative process.
Lazy? No: The function needs to explore the whole stream
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    length of <CODE>xs</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">number</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_map"><span class="type-signature"></span>stream_map<span class="signature">(f, xs)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Returns a stream that results from stream
<CODE>xs</CODE> by element-wise application
of unary function <CODE>f</CODE>.
<CODE>f</CODE> is applied element-by-element:
<CODE>stream_map(f, stream(1,2))</CODE> results in
the same as <CODE>stream(f(1),f(2))</CODE>.
Lazy? Yes: The argument stream is only explored as forced by
           the result stream.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>f</code></td>
            

            <td class="type">
            
                
<span class="param-type">function</span>


            </td>

            
            <td class="description last">unary</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    result of mapping
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_member"><span class="type-signature"></span>stream_member<span class="signature">(v, xs)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Returns first postfix substream
whose head is identical to
<CODE>v</CODE> (using <CODE>===</CODE>); returns <CODE>null</CODE> if the
element does not occur in the stream.
Iterative process.
Lazy? Sort-of: <CODE>stream_member</CODE>
forces the stream only until the element
is found.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    postfix substream that starts with <CODE>v</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_ref"><span class="type-signature"></span>stream_ref<span class="signature">(xs, n)</span><span class="type-signature"> &rarr; {value}</span></h4>
    

<div class="description">
    Returns the element
of stream <CODE>xs</CODE> at position <CODE>n</CODE>,
where the first element has index 0.
Iterative process.
Lazy? Sort-of: <CODE>stream_ref</CODE> only forces the computation of
               the first <CODE>n</CODE> elements, and leaves the rest of
               the stream untouched.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>n</code></td>
            

            <td class="type">
            
                
<span class="param-type">number</span>


            </td>

            
            <td class="description last">given position</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    item in <CODE>xs</CODE> at position <CODE>n</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">value</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_remove"><span class="type-signature"></span>stream_remove<span class="signature">(v, xs)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Returns a stream that results from
<CODE>xs</CODE> by removing the first item from <CODE>xs</CODE> that
is identical (<CODE>===</CODE>) to <CODE>v</CODE>.
Returns the original
stream if there is no occurrence.
Lazy? Yes: the result stream forces the construction of each next element
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    <CODE>xs</CODE> with first occurrence of <CODE>v</CODE> removed
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_remove_all"><span class="type-signature"></span>stream_remove_all<span class="signature">(v, xs)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Returns a stream that results from
<CODE>xs</CODE> by removing all items from <CODE>xs</CODE> that
are identical (<CODE>===</CODE>) to <CODE>v</CODE>.
Returns the original
stream if there is no occurrence.
Recursive process.
Lazy? Yes: the result stream forces the construction of each next
element
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">given value</td>
        </tr>

    
        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    <CODE>xs</CODE> with all occurrences of <CODE>v</CODE> removed
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_reverse"><span class="type-signature"></span>stream_reverse<span class="signature">(xs)</span><span class="type-signature"> &rarr; {<a href="global.html#stream">stream</a>}</span></h4>
    

<div class="description">
    Returns stream <CODE>xs</CODE> in reverse
order. Iterative process.
The process is iterative, but consumes space <CODE>Omega(n)</CODE>
because of the result stream.
Lazy? No: <CODE>stream_reverse</CODE>
forces the exploration of the entire stream
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    <CODE>xs</CODE> in reverse
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#stream">stream</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_tail"><span class="type-signature"></span>stream_tail<span class="signature">(xs)</span><span class="type-signature"> &rarr; {Stream}</span></h4>
    

<div class="description">
    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.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type">Stream</span>


            </td>

            
            <td class="description last">given stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    result stream (if stream discipline is used)
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">Stream</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stream_to_list"><span class="type-signature"></span>stream_to_list<span class="signature">(xs)</span><span class="type-signature"> &rarr; {<a href="global.html#list">list</a>}</span></h4>
    

<div class="description">
    Given stream <CODE>xs</CODE>, returns a list of same length with
the same elements as <CODE>xs</CODE> in the same order.
Laziness:  No: <CODE>stream_to_list</CODE> needs to force the whole
stream.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>xs</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#stream">stream</a></span>


            </td>

            
            <td class="description last">stream</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    containing all elements of <CODE>xs</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type"><a href="global.html#list">list</a></span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="stringify"><span class="type-signature"></span>stringify<span class="signature">(v)</span><span class="type-signature"> &rarr; {string}</span></h4>
    

<div class="description">
    returns a string that represents the value <CODE>v</CODE>, using a
notation that is is consistent with
<a href="http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf">JSON</a>,
but also displays <CODE>undefined</CODE>, <CODE>NaN</CODE>, <CODE>Infinity</CODE>, and function objects.
See also <a href="https://sourceacademy.org/sicpjs/3.3.5">textbook example</a>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>v</code></td>
            

            <td class="type">
            
                
<span class="param-type">value</span>


            </td>

            
            <td class="description last">the argument value</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    string representation of v
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">string</span>


    </dd>
</dl>

    
            </div>
        
            <div class="function-entry">
                

    <h4 class="name" id="tail"><span class="type-signature"></span>tail<span class="signature">(p)</span><span class="type-signature"> &rarr; {value}</span></h4>
    

<div class="description">
    **primitive**; returns tail (second component of given pair <CODE>p</CODE>; time: <CODE>Theta(1)</CODE, space: <CODE>Theta(1)</CODE>.
</div>


    <h5>Parameters:</h5>
    

<table class="params">
    <thead>
    <tr>
        
        <th>Name</th>
        

        <th>Type</th>

        
        <th class="last">Description</th>
    </tr>
    </thead>

    <tbody>
    

        <tr>
            
                <td class="name"><code>p</code></td>
            

            <td class="type">
            
                
<span class="param-type"><a href="global.html#pair">pair</a></span>


            </td>

            
            <td class="description last">given pair</td>
        </tr>

    
    </tbody>
</table>


<dl class="details">

    
</dl>


<h5>Returns:</h5>

        
<div class="param-desc">
    tail of <CODE>p</CODE>
</div>


<dl>
    <dt>
        Type
    </dt>
    <dd>
        
<span class="param-type">value</span>


    </dd>
</dl>

    
            </div>
        
    
</article>

</section>


</div>

<nav>
    <h3>Predeclared names</h3><ul><li><a href="global.html#__access_export__">__access_export__</a></li><li><a href="global.html#__access_named_export__">__access_named_export__</a></li><li><a href="global.html#accumulate">accumulate</a></li><li><a href="global.html#append">append</a></li><li><a href="global.html#arity">arity</a></li><li><a href="global.html#array_length">array_length</a></li><li><a href="global.html#build_list">build_list</a></li><li><a href="global.html#build_stream">build_stream</a></li><li><a href="global.html#char_at">char_at</a></li><li><a href="global.html#display">display</a></li><li><a href="global.html#display_list">display_list</a></li><li><a href="global.html#draw_data">draw_data</a></li><li><a href="global.html#enum_list">enum_list</a></li><li><a href="global.html#enum_stream">enum_stream</a></li><li><a href="global.html#equal">equal</a></li><li><a href="global.html#error">error</a></li><li><a href="global.html#eval_stream">eval_stream</a></li><li><a href="global.html#filter">filter</a></li><li><a href="global.html#for_each">for_each</a></li><li><a href="global.html#get_time">get_time</a></li><li><a href="global.html#head">head</a></li><li><a href="global.html#Infinity">Infinity</a></li><li><a href="global.html#integers_from">integers_from</a></li><li><a href="global.html#is_array">is_array</a></li><li><a href="global.html#is_boolean">is_boolean</a></li><li><a href="global.html#is_function">is_function</a></li><li><a href="global.html#is_list">is_list</a></li><li><a href="global.html#is_null">is_null</a></li><li><a href="global.html#is_number">is_number</a></li><li><a href="global.html#is_pair">is_pair</a></li><li><a href="global.html#is_stream">is_stream</a></li><li><a href="global.html#is_string">is_string</a></li><li><a href="global.html#is_undefined">is_undefined</a></li><li><a href="global.html#length">length</a></li><li><a href="global.html#list">list</a></li><li><a href="global.html#list_ref">list_ref</a></li><li><a href="global.html#list_to_stream">list_to_stream</a></li><li><a href="global.html#list_to_string">list_to_string</a></li><li><a href="global.html#map">map</a></li><li><a href="global.html#math_abs">math_abs</a></li><li><a href="global.html#math_acos">math_acos</a></li><li><a href="global.html#math_acosh">math_acosh</a></li><li><a href="global.html#math_asin">math_asin</a></li><li><a href="global.html#math_asinh">math_asinh</a></li><li><a href="global.html#math_atan">math_atan</a></li><li><a href="global.html#math_atan2">math_atan2</a></li><li><a href="global.html#math_atanh">math_atanh</a></li><li><a href="global.html#math_cbrt">math_cbrt</a></li><li><a href="global.html#math_ceil">math_ceil</a></li><li><a href="global.html#math_clz32">math_clz32</a></li><li><a href="global.html#math_cos">math_cos</a></li><li><a href="global.html#math_cosh">math_cosh</a></li><li><a href="global.html#math_E">math_E</a></li><li><a href="global.html#math_exp">math_exp</a></li><li><a href="global.html#math_expm1">math_expm1</a></li><li><a href="global.html#math_floor">math_floor</a></li><li><a href="global.html#math_fround">math_fround</a></li><li><a href="global.html#math_hypot">math_hypot</a></li><li><a href="global.html#math_imul">math_imul</a></li><li><a href="global.html#math_LN2">math_LN2</a></li><li><a href="global.html#math_LN10">math_LN10</a></li><li><a href="global.html#math_log">math_log</a></li><li><a href="global.html#math_log1p">math_log1p</a></li><li><a href="global.html#math_log2">math_log2</a></li><li><a href="global.html#math_LOG2E">math_LOG2E</a></li><li><a href="global.html#math_log10">math_log10</a></li><li><a href="global.html#math_LOG10E">math_LOG10E</a></li><li><a href="global.html#math_max">math_max</a></li><li><a href="global.html#math_min">math_min</a></li><li><a href="global.html#math_PI">math_PI</a></li><li><a href="global.html#math_pow">math_pow</a></li><li><a href="global.html#math_random">math_random</a></li><li><a href="global.html#math_round">math_round</a></li><li><a href="global.html#math_sign">math_sign</a></li><li><a href="global.html#math_sin">math_sin</a></li><li><a href="global.html#math_sinh">math_sinh</a></li><li><a href="global.html#math_sqrt">math_sqrt</a></li><li><a href="global.html#math_SQRT1_2">math_SQRT1_2</a></li><li><a href="global.html#math_SQRT2">math_SQRT2</a></li><li><a href="global.html#math_tan">math_tan</a></li><li><a href="global.html#math_tanh">math_tanh</a></li><li><a href="global.html#math_trunc">math_trunc</a></li><li><a href="global.html#member">member</a></li><li><a href="global.html#NaN">NaN</a></li><li><a href="global.html#pair">pair</a></li><li><a href="global.html#parse_int">parse_int</a></li><li><a href="global.html#prompt">prompt</a></li><li><a href="global.html#remove">remove</a></li><li><a href="global.html#remove_all">remove_all</a></li><li><a href="global.html#reverse">reverse</a></li><li><a href="global.html#set_head">set_head</a></li><li><a href="global.html#set_tail">set_tail</a></li><li><a href="global.html#stream">stream</a></li><li><a href="global.html#stream_append">stream_append</a></li><li><a href="global.html#stream_filter">stream_filter</a></li><li><a href="global.html#stream_for_each">stream_for_each</a></li><li><a href="global.html#stream_length">stream_length</a></li><li><a href="global.html#stream_map">stream_map</a></li><li><a href="global.html#stream_member">stream_member</a></li><li><a href="global.html#stream_ref">stream_ref</a></li><li><a href="global.html#stream_remove">stream_remove</a></li><li><a href="global.html#stream_remove_all">stream_remove_all</a></li><li><a href="global.html#stream_reverse">stream_reverse</a></li><li><a href="global.html#stream_tail">stream_tail</a></li><li><a href="global.html#stream_to_list">stream_to_list</a></li><li><a href="global.html#stringify">stringify</a></li><li><a href="global.html#tail">tail</a></li><li><a href="global.html#undefined">undefined</a></li></ul>
</nav>

<br class="clear">

<footer>
  generated by <a href="https://github.com/jsdoc/jsdoc">JSDoc 3.6.11</a> from
  <a href="https://github.com/source-academy/js-slang">Github repository js-slang</a>
  on Wed Apr 23 2025 02:49:20 GMT+0000 (Coordinated Universal Time)
</footer>

<script> prettyPrint(); </script>
<script src="scripts/linenumber.js"> </script>
</body>
</html>