Intrepydd functions reference¶

This notebook serves as a "executable" reference guide to the functions available in reference, as summarized here in the Intrepydd Guide.

Run these first. If you are executing this reference, please run the following two code cells first. You can then run any subsection, as there are no additional dependencies among them.

In [1]:

from os import makedirs
makedirs('ref', exist_ok=True)

In [2]:

from numpy import array, float32, int32

Table of contents¶

The following Python builtins have counterparts in Intrepydd.

abs: Absolute value of an iterable collection
all: Check whether all elements of an iterable collection are True
any: Check whether any element of an iterable collection is True
len: Returns the length of an iterable collection
max: Returns the largest value in an iterable collection
pow: Raises a given value or every element of an iterable object to some power
range: Generates an integer range (sequence).
sum: Returns the sum of the elements in an iterable object.
Type conversion:int32, int64, float32, float64: Constructors and converters for basic primitive types.

Intrepydd also provides counterparts to a subset of the functions available in Numpy/Scipy.

Basic arithmetic, unary operators elemwise_not, minus: Elementwise arithmetic on a single input array.
Basic arithmetic, binary operators add, sub, mul, div: Elementwise arithmetic between pairs of arrays.
Comparisons eq, ge, gt, le, lt: Elementwise signed comparison (e.g., equality, less than, greater than).
Trignometric functions, acos, asin, atan, cos, sin, sqrt, tan: Elementwise trigonometric functions.
allclose: Returns True if all elements of a given array are close to a given value.
argmin: Returns the location of the minimum value in an array.
argmax: Returns the location of the maximum value in an array.
empty: Returns an "empty" (uninitialized) multidimensional array.
innerprod: Returns the inner product (dot-product) between two arrays of the same size.
isinf, isnan: Tests for IEEE-754 floating-point infinity (inf) and not-a-number (NaN) values.
prod: Returns the product of all elements of a collection.
transpose: Returns the transpose of a matrix.
zeros: Returns an array of all zero elements.

Python builtin-equivalents¶

Function: `abs`¶

Returns the absolute value of a given object or iterable; equivalent to its Python builtin.

Example.

In [3]:

%%writefile ref/abs.pydd

def demo_float32(x: float32) -> float32:
    return abs(x)

def demo_Array(x: Array(float64, 2)) -> Array(float64, 2):
    return abs(x)

Overwriting ref/abs.pydd

In [4]:

!pyddc ref/abs.pydd

In [5]:

import ref.abs
print(ref.abs.demo_float32(-3.14))

A = array([[-1., 2., -3.],
           [4., -5., 6.]])
print(ref.abs.demo_Array(A))

3.140000104904175
[[1. 2. 3.]
 [4. 5. 6.]]

Function: `all`¶

Returns True if all elements of a given iterable object are True; equivalent to its Python builtin.

Example.

In [6]:

%%writefile ref/all.pydd

def demo_bool(A: Array(bool, 2)) -> bool:
    return all(A)

def demo_int(A: Array(int64)) -> bool:
    return all(A)

def demo_double(A: Array(float64, 2)) -> bool:
    return all(A)

Overwriting ref/all.pydd

In [7]:

!pyddc ref/all.pydd

In [8]:

import ref.all

A = array(2 * [3 * [True]])
print(ref.all.demo_bool(A))

A[0, 1] = False
print(ref.all.demo_bool(A))

L = array(range(10)) # Doesn't work with `list(range(10))`
print(L)
print(ref.all.demo_int(L)) # False

L[0] = -1
print(ref.all.demo_int(L)) # True

A = array([[1., -2., 3.],
           [-4., 5., 6.]])
print(A)
print(ref.all.demo_double(A))

A[-1, -1] = 0.0
print(A)
print(ref.all.demo_double(A))

True
False
[0 1 2 3 4 5 6 7 8 9]
False
True
[[ 1. -2.  3.]
 [-4.  5.  6.]]
True
[[ 1. -2.  3.]
 [-4.  5.  0.]]
False

Function: `any`¶

Returns True if any element of a given iterable object is True; equivalent to its Python builtin.

Example.

In [9]:

%%writefile ref/any.pydd

def demo_bool(A: Array(bool, 2)) -> bool:
    return any(A)

def demo_int(A: Array(int64)) -> bool:
    return any(A)

def demo_double(A: Array(float64, 2)) -> bool:
    return any(A)

Overwriting ref/any.pydd

In [10]:

!pyddc ref/any.pydd

In [11]:

import ref.any

A = array(2 * [3 * [False]])
print(ref.any.demo_bool(A))

A[0, 1] = True
print(ref.any.demo_bool(A))

L = array([0] * 5) # Doesn't work with `list(range(10))`
print(L)
print(ref.any.demo_int(L)) # False

L[0] = -1
print(ref.any.demo_int(L)) # True

False
True
[0 0 0 0 0]
False
True

Function: `len`¶

Returns the length of the object; equivalent to its Python builtin.

Example.

In [12]:

%%writefile ref/len.pydd

def demo_list(L: List(int)) -> int64:
    return len(L)

def demo_dict(D: Dict(int64, float64)) -> int64:
    return len(D)

Overwriting ref/len.pydd

In [13]:

!pyddc ref/len.pydd

In [14]:

import ref.len
print(ref.len.demo_list([-1, -2, -3]))
print(ref.len.demo_dict({1: 3.14, 2: 2.718, 3: 6.9824, 4: -1.2}))

3
4

Function: `max`¶

Returns the maximum value of an iterable; equivalent to its Python builtin.

Example.

In [15]:

%%writefile ref/max.pydd

def demo_int(A: Array(int64, 1)) -> int64:
    return max(A)

def demo_float32_2d(A: Array(float32, 2)) -> float32:
    return max(A)

Overwriting ref/max.pydd

In [16]:

!pyddc ref/max.pydd

In [17]:

import ref.max
print(ref.max.demo_int(array([3, 2, 100, 7])))
print(ref.max.demo_float32_2d(array([[3, 2, 100, 33], [-500, 1, 0, -40]], dtype=float32)))

100
100.0

Function: `min`¶

Returns the maximum value of an iterable object; equivalent to its Python builtin.

Example.

In [18]:

%%writefile ref/min.pydd

def demo_int(A: Array(int64, 1)) -> int64:
    return min(A)

def demo_float32_2d(A: Array(float32, 2)) -> float32:
    return min(A)

Overwriting ref/min.pydd

In [19]:

!pyddc ref/min.pydd

In [20]:

import ref.min
print(ref.min.demo_int(array([3, 2, 100, 7])))
print(ref.min.demo_float32_2d(array([[3, 2, 100, 33], [-500, 1, 0, -40]], dtype=float32)))

2
-500.0

Function: `pow`¶

Raises a given value or every element of an iterable object to some power; equivalent to its Python builtin.

In [21]:

%%writefile ref/pow.pydd

def demo_float32(x: float32, p: float32) -> float32:
    return pow(x, p)

def demo_float32_1d(A: Array(float32, 1), p: float32) -> Array(float32, 1):
    return pow(A, p)

Overwriting ref/pow.pydd

In [22]:

!pyddc ref/pow.pydd

In [23]:

import ref.pow

print(ref.pow.demo_float32(3.14, 2.0))
print(ref.pow.demo_float32_1d(array([3.14, -3.14], dtype=float32), 3.0))

9.859601020812988
[ 30.959146 -30.959146]

Function: `print`¶

Prints a value to standard output.

This function is equivalent to its Python builtin. However, in the current version of Intrepydd, it is limited to accepting just one argument, i.e., print(x), where x must be a primitive type.

In [24]:

%%writefile ref/print.pydd

def demo_float32(x: float32):
    print(x)

def demo_float32_1d(A: Array(float32, 1)):
    for i in range(shape(A, 0)):
        print(A[i])

Overwriting ref/print.pydd

In [25]:

!pyddc ref/print.pydd

In [26]:

import ref.print
ref.print.demo_float32(3.14)
ref.print.demo_float32_1d(array([1, 2, 3], dtype=float32))

3.140000104904175
1.0
2.0
3.0

Function: `range`¶

Generates an integer range (sequence); equivalent to its Python builtin.

In [27]:

%%writefile ref/range.pydd

def demo_std(n: int64) -> int64:
    s = 0
    for i in range(n):
        s += i
        print(i)
    return s
        
def demo_start_end(a: int64, b: int64) -> int64:
    s = 0
    for i in range(a, b):
        print(i)
        s += i
    return s

def demo_start_end_step(a: int64, b: int64, c: int64) -> int64:
    s = 0
    for i in range(a, b, c):
        print(i)
        s += i
    return s

Overwriting ref/range.pydd

In [28]:

!pyddc ref/range.pydd

In [29]:

import ref.range
ref.range.demo_std(5)
ref.range.demo_start_end(-3, 7)
ref.range.demo_start_end_step(-3, 7, 2)

Out[29]:

Function: `sum`¶

Returns the sum of the elements in an iterable object.

This function is equivalent to its Python builtin, except it does not support the optional start argument, i.e., it does not support the calling signature, sum(x, start), where in standard Python start is the position of the first index at which to begin the sum.

In [30]:

%%writefile ref/sum.pydd

def demo(x: Array(int64, 2)) -> int64:
    return sum(x)

Overwriting ref/sum.pydd

In [31]:

!pyddc ref/sum.pydd

In [32]:

import ref.sum
ref.sum.demo(array([[1, 2, 3, 4, 5],
                    [6, 7, 8, 9, 10]]))

Out[32]:

Type conversion¶

Construct or convert scalar variables among primitive types: int32, int64, float32, float64.

Example: float32.

In [33]:

%%writefile ref/types.pydd

def do_float32() -> float32:
    return float32()

def do_float32_2(val: int32) -> float32:
    return float32(val)

Overwriting ref/types.pydd

In [34]:

!pyddc ref/types.pydd

In [35]:

import ref.types

print(ref.types.do_float32()) # 0, as a float
print(ref.types.do_float32_2(124))
print(ref.types.do_float32_2(True))

0.0
124.0
1.0

Numpy equivalents¶

Basic arithmetic: unary operators, `elemwise_not`, `minus`¶

Applies basic arithmetic options elementwise to an input. These are equivalent to their Numpy counterparts; e.g., see Numpy's logical_not.

Example: minus.

In [36]:

%%writefile ref/minus.pydd

def demo_float32(x: Array(float32, 2)) -> Array(float32, 2):
    return minus(x)

def demo_int64(x: Array(int64, 2)) -> Array(int64, 2):
    return minus(x)

Overwriting ref/minus.pydd

In [37]:

!pyddc ref/minus.pydd

In [38]:

import ref.minus
x = array([[1, 2, 3], [4, 5, 6]], dtype=float32)
ref.minus.demo_float32(x)

Out[38]:

array([[-1., -2., -3.],
       [-4., -5., -6.]], dtype=float32)

In [39]:

y = array([[1, -2, 3], [-4, 5, -6]], dtype=int)
ref.minus.demo_int64(y)

Out[39]:

array([[-1,  2, -3],
       [ 4, -5,  6]])

Basic arithmetic: binary operators, `add`, `sub`, `mul`, `div`¶

Applies basic arithmetic options elementwise to a pair of inputs. These are equivalent to their Numpy counterparts; e.g., see Numpy's add.

Example: add.

In [40]:

%%writefile ref/add.pydd

def demo_float32(x: Array(float32, 2), y: Array(float32, 2)) -> Array(float32, 2):
    return add(x, y)

def demo_int64(x: Array(int64, 2), y: Array(int64, 2)) -> Array(int64, 2):
    return add(x, y)

Overwriting ref/add.pydd

In [41]:

!pyddc ref/add.pydd

In [42]:

import ref.add
x = array([[1, 2, 3], [4, 5, 6]], dtype=float32)
y = array([[1, -2, 3], [-4, 5, -6]], dtype=float32)
ref.add.demo_float32(x, y)

Out[42]:

array([[ 2.,  0.,  6.],
       [ 0., 10.,  0.]], dtype=float32)

In [43]:

x = array([[1, 2, 3], [4, 5, 6]], dtype=int)
y = array([[1, -2, 3], [-4, 5, -6]], dtype=int)
ref.add.demo_int64(x, y)

Out[43]:

array([[ 2,  0,  6],
       [ 0, 10,  0]], dtype=int64)

Comparisons: binary logical operators, `eq`, `ge`, `gt`, `le`, `lt`¶

Given a pair of inputs, performs elementwise binary comparisons: equality (eq), greater than (gt), greater than or equal to (ge), less than (lt), and less than or equal to (le). These are equivalent to their Numpy counterparts; e.g., see Numpy's eq for an example of equality comparison.

When the inputs are floating-point, it is usually better to apply allclose rather than eq to test for approximate equality due to round-off errors with floating-point arithmetic.

Example: greater than (gt).

In [44]:

%%writefile ref/gt.pydd

def demo_float32(x: Array(float32, 2), y: Array(float32, 2)) -> Array(bool, 2):
    return gt(x, y)

def demo_int64(x: Array(int64, 2), y: Array(int64, 2)) -> Array(bool, 2):
    return gt(x, y)

Overwriting ref/gt.pydd

In [45]:

!pyddc ref/gt.pydd

In [46]:

import ref.gt
eps = 1e-6 # greater than float32 machine epsilon
x = array([[1, 2, 3], [4, 5, 6]], dtype=float32)
y = x + eps*array([[1, -1, 1], [-1, 0, -1]], dtype=float32)
ref.gt.demo_float32(x, y)

Out[46]:

array([[False,  True, False],
       [ True, False,  True]])

In [47]:

x = array([[1, 2, 3], [4, 5, 6]], dtype=int)
y = x + array([[1, -1, 1], [-1, 0, -1]], dtype=int)
ref.gt.demo_int64(x, y)

Out[47]:

array([[False,  True, False],
       [ True, False,  True]])

Elementary functions: `acos`, `asin`, `atan`, `cos`, `exp`, `log`, `sin`, `sqrt`, `tan`¶

Applies trigonometric function elementwise and returns the result. These are equivalent to their Numpy equivalents, e.g., see Numpy's arccos.

Example: acos.

In [48]:

%%writefile ref/acos.pydd

def demo(x: Array(float32, 2)) -> Array(float32, 2):
    return acos(x)

Overwriting ref/acos.pydd

In [49]:

!pyddc ref/acos.pydd

In [50]:

import math
import ref.acos
theta_over_pi = ref.acos.demo(array([[-1, -0.5, 0],
                                     [0, 0.5, 1]], dtype=float32))/math.pi
print('{} * pi'.format(theta_over_pi))

[[0.99999994 0.6666667  0.5       ]
 [0.5        0.33333328 0.        ]] * pi

Function: `allclose`¶

Returns True if all elements of a given array are close to a given value.

This function implements allclose(x, atol), where x is an input array and atol is an absolute threshold. Therefore, Intrepydd's allclose is similar to, but not equivalent to, its Numpy counterpart.

Numpy's allclose. In particular, Numpy's allclose evaluates the logical operation $\bigwedge_i \left( |a_i - b_i| \leq \alpha + \rho |b_i| \right)$ , where $\bigwedge$ denotes logical-and, $a_i$ and $b_i$ are the elements of two arrays, and $\alpha$ and $\rho$ are absolute and relative threshold parameters, respectively. (The values of $\alpha$ and $\rho$ are the atol and rtol arguments to allclose().) For instance, suppose we have two Numpy arrays, a and b, and suppose the absolute difference between any pair of corresponding elements is $10^{-10}$ .

# Numpy allclose
from numpy import allclose, array
tiny_diff = 1e-10
a = array([1., 2., 3.])
b = a + array([tiny_diff, -tiny_diff, tiny_diff])

Consider two calls to allclose: one that checks whether the absolute difference is less than $10^{-11}$ , which will be false, and the other that checks against $10^{-9}$ , which will be true.

print(allclose(a, b, atol=1e-11, rtol=0)) # False!
print(allclose(a, b, atol=1e-9, rtol=0)) # True!

Intrepydd's allclose. By contrast, Intrepydd's interface, allclose(x, atol), is "lighter." It accepts just a single array (x) and an absolute tolerance (atol). There is no direct relative tolerance support (but see below!). The previous two checks would be rewritten as follows:

# Intrepydd:
    allclose(abs(a-b), 1e-11)  # False!
    allclose(abs(a-b), 1e-9)   # True!

To implement something like Numpy's allclose(), which accepts both atol and rtol parameters, see the demo function in the code cells below.

In [51]:

from numpy import allclose, array
a = array([1., 2., 3.])
b = a + array([1e-10, -1e-10, 1e-10])
print(a-b)
print(allclose(a, b, atol=1e-11, rtol=0)) # False!
print(allclose(a, b, atol=1e-9, rtol=0)) # True!

[-1.00000008e-10  1.00000008e-10 -1.00000008e-10]
False
True

In [52]:

%%writefile ref/allclose.pydd

def scale_array(x: Array(float64, 2), s: float64) -> Array(float64, 2):
    y = empty([shape(x, 0), shape(x, 1)])
    for i in range(shape(y, 0)):
        for j in range(shape(y, 1)):
            y[i, j] = x[i, j] * s
    return y

def demo(a: Array(float64, 2), b: Array(float64, 2), atol: float64, rtol: float64) -> bool:
    diff = abs(sub(a, b))
    relterm = abs(scale_array(b, rtol))
    x = sub(diff, relterm)
    return allclose(x, atol)

Overwriting ref/allclose.pydd

In [53]:

!pyddc ref/allclose.pydd

In [54]:

import ref.allclose

a = array([[1., 2., 3.],
           [4., 5., 6.]])
b = a + 1e-10
print(ref.allclose.demo(a, b, 1e-11, 0.)) # False?
print(ref.allclose.demo(a, b, 1e-9, 0.))  # True?

False
True

Function: `argmin`¶

Returns the location of the minimum value of an array; equivalent to its Numpy counterpart.

The return value is a list, since the input array may be multidimensional. A best-practice in the current version of Intrepydd is to recast this return as an array before returning, as the following example shows.

If there are duplicates, one of them will be returned. The precise one is not specified.

In [55]:

%%writefile ref/argmin.pydd

def demo(A: Array(float64, 3)) -> Array(int32) :
    r = argmin(A)
    r_np = empty((3,), int32())
    r_np[0] = r[0]
    r_np[1] = r[1]
    r_np[2] = r[2]
    return r_np

Overwriting ref/argmin.pydd

In [56]:

!pyddc ref/argmin.pydd

In [57]:

import ref.argmin
plane = array([[1., 2., 3.],
               [4., 5., 6.]])
x = array([plane, -plane, plane])
loc = ref.argmin.demo(x)
print(loc, ':', type(loc))
print("Min value is {}, which resides at location x{}".format(x[loc[0], loc[1], loc[2]], loc))

[1 1 2] : <class 'numpy.ndarray'>
Min value is -6.0, which resides at location x[1 1 2]

Function: `argmax`¶

Returns the location of the maximum value of an array; equivalent to its Numpy counterpart.

The return value is a list, since the input array may be multidimensional. A best-practice in the current version of Intrepydd is to recast this return as an array before returning, as the following example shows.

If there are duplicates, one of them will be returned. The precise one is not specified.

In [58]:

%%writefile ref/argmax.pydd

def demo(A: Array(float64, 3)) -> Array(int32) :
    r = argmax(A)
    r_np = empty((3,), int32())
    r_np[0] = r[0]
    r_np[1] = r[1]
    r_np[2] = r[2]
    return r_np

Overwriting ref/argmax.pydd

In [59]:

!pyddc ref/argmax.pydd

In [60]:

import ref.argmax
plane = array([[1., 2., 3.],
               [4., 5., 6.]])
x = array([-plane, plane, -plane])
loc = ref.argmax.demo(x)
print(loc, ':', type(loc))
print("Max value is {}, which resides at location x{}".format(x[loc[0], loc[1], loc[2]], loc))

[1 1 2] : <class 'numpy.ndarray'>
Max value is 6.0, which resides at location x[1 1 2]

Function: `empty`¶

Returns an "empty" (uninitialized) multidimensional array; equivalent to its Numpy counterpart.

Intrepydd does not currently implement the order parameter, which would be used to specify row- vs. column-major layouts. Intrepydd's default is row-major.

In [61]:

%%writefile ref/empty.pydd

def demo_int32(shape: List(int32)) -> Array(int32):
    return empty(shape, int32())

def demo_float64(shape: List(int32)) -> Array(float64):
    return empty(shape, float64())

Overwriting ref/empty.pydd

In [62]:

!pyddc ref/empty.pydd

In [63]:

import ref.empty
A = ref.empty.demo_int32([2, 3, 2])
print(type(A), A.dtype)
print(A)

B = ref.empty.demo_float64([2, 3, 2])
print(type(B), B.dtype)
print(B)

<class 'numpy.ndarray'> int32
[[[          0 -1074790400]
  [          0 -1073741824]
  [          0 -1073217536]]

 [[          0 -1072693248]
  [          0 -1072431104]
  [          0 -1072168960]]]
<class 'numpy.ndarray'> float64
[[[-8.39911598e-323 -0.00000000e+000]
  [ 1.49458072e-154 -0.00000000e+000]
  [ 7.41098469e-323  0.00000000e+000]]

 [[ 0.00000000e+000  0.00000000e+000]
  [ 0.00000000e+000  0.00000000e+000]
  [ 0.00000000e+000  0.00000000e+000]]]

Function: `innerprod`¶

Returns the inner product (dot-product) between two arrays of the same size. Its closest counterpart in Numpy is numpy.ma.innerproduct.

In [64]:

%%writefile ref/innerprod.pydd

def func(A: Array(int32, 1), B: Array(float64, 1)) -> float64:
    return innerprod(A, B)

Overwriting ref/innerprod.pydd

In [65]:

!pyddc ref/innerprod.pydd

In [66]:

import ref.innerprod

x = array([1, 2, 3], dtype=int32)
y = array([1., 2., 3.])

ref.innerprod.func(x, y)

Out[66]:

14.0

Functions: `isinf`, `isnan`¶

Tests whether values of an array are IEEE floating-point infinity (inf) or not-a-number (NaN) values; equivalent to the Numpy functions numpy.isinf and numpy.isnan.

In [67]:

%%writefile ref/isfpXXX.pydd

def demo_isinf(x: Array(float64, 2)) -> Array(bool, 2):
    return isinf(x)

def demo_isnan(x: Array(float32, 2)) -> Array(bool, 2):
    return isnan(x)

Overwriting ref/isfpXXX.pydd

In [68]:

!pyddc ref/isfpXXX.pydd

In [69]:

import ref.isfpXXX

z = array([[1.0, float('inf'), 0.0],
           [float('nan'), -2.0, float('inf')]])

print(ref.isfpXXX.demo_isinf(z))
print(ref.isfpXXX.demo_isnan(z.astype(float32)))

[[False  True False]
 [False False  True]]
[[False False False]
 [ True False False]]

Function: `prod`¶

Returns the product of all elements of a collection; equivalent to its Numpy counterpart.

In [70]:

%%writefile ref/prod.pydd

def demo(arr: Array(int64)) -> int64:
    return prod(arr)

Overwriting ref/prod.pydd

In [71]:

!pyddc ref/prod.pydd

In [72]:

import ref.prod
ref.prod.demo(array([1, -2, 3, 5], dtype=int))

Out[72]:

-30

Function: `transpose`¶

Returns the transpose of a matrix.

This function is roughly equivalent to its Numpy counterpart, except that it works only for matrix (2-D) inputs.

In [73]:

%%writefile ref/transpose.pydd

def demo(arr: Array(int32, 2)) -> Array(int32, 2):
    return transpose(arr)

Overwriting ref/transpose.pydd

In [74]:

!pyddc ref/transpose.pydd

In [75]:

import ref.transpose
ref.transpose.demo(array([[1, 2, 3], [4, 5, 6]], dtype=int32))

Out[75]:

array([[1, 4],
       [2, 5],
       [3, 6]], dtype=int32)

Function: `zeros`¶

Returns an array of all zeros; equivalent to its Numpy counterpart.

In [76]:

%%writefile ref/zeros.pydd

def zeros_1d(n: int) -> Array(float64, 1):
    return zeros(n, float64())

def ones_2d(m:int, n: int) -> Array(float64, 2):
    C = zeros([m, n], float64())
    return cos(C)

Overwriting ref/zeros.pydd

In [77]:

!pyddc ref/zeros.pydd

In [78]:

import ref.zeros
print(ref.zeros.zeros_1d(4))
print(ref.zeros.ones_2d(2, 3))

[0. 0. 0. 0.]
[[1. 1. 1.]
 [1. 1. 1.]]

In [ ]:

Intrepydd functions reference¶

Table of contents¶

Python builtin-equivalents¶

Function: abs¶

Function: all¶

Function: any¶

Function: len¶

Function: max¶

Function: min¶

Function: pow¶

Function: print¶

Function: range¶

Function: sum¶

Type conversion¶

Numpy equivalents¶

Basic arithmetic: unary operators, elemwise_not, minus¶

Basic arithmetic: binary operators, add, sub, mul, div¶

Comparisons: binary logical operators, eq, ge, gt, le, lt¶

Elementary functions: acos, asin, atan, cos, exp, log, sin, sqrt, tan¶

Function: allclose¶

Function: argmin¶

Function: argmax¶

Function: empty¶

Function: innerprod¶

Functions: isinf, isnan¶

Function: prod¶

Function: transpose¶

Function: zeros¶

Function: `abs`¶

Function: `all`¶

Function: `any`¶

Function: `len`¶

Function: `max`¶

Function: `min`¶

Function: `pow`¶

Function: `print`¶

Function: `range`¶

Function: `sum`¶

Basic arithmetic: unary operators, `elemwise_not`, `minus`¶

Basic arithmetic: binary operators, `add`, `sub`, `mul`, `div`¶

Comparisons: binary logical operators, `eq`, `ge`, `gt`, `le`, `lt`¶

Elementary functions: `acos`, `asin`, `atan`, `cos`, `exp`, `log`, `sin`, `sqrt`, `tan`¶

Function: `allclose`¶

Function: `argmin`¶

Function: `argmax`¶

Function: `empty`¶

Function: `innerprod`¶

Functions: `isinf`, `isnan`¶

Function: `prod`¶

Function: `transpose`¶

Function: `zeros`¶