SYMBOL INDEX (1282 symbols across 93 files)

FILE: autograd/builtins.py
  function container_take (line 25) | def container_take(A, idx):
  function grad_container_take (line 29) | def grad_container_take(ans, A, idx):
  class SequenceBox (line 37) | class SequenceBox(Box):
    method __len__ (line 41) | def __len__(self):
    method __add__ (line 44) | def __add__(self, other):
    method __radd__ (line 47) | def __radd__(self, other):
    method __contains__ (line 50) | def __contains__(self, elt):
    method index (line 53) | def index(self, elt):
  class DictBox (line 61) | class DictBox(Box):
    method __len__ (line 65) | def __len__(self):
    method __iter__ (line 68) | def __iter__(self):
    method __contains__ (line 71) | def __contains__(self, elt):
    method items (line 74) | def items(self):
    method keys (line 77) | def keys(self):
    method values (line 80) | def values(self):
    method iteritems (line 83) | def iteritems(self):
    method iterkeys (line 86) | def iterkeys(self):
    method itervalues (line 89) | def itervalues(self):
    method get (line 92) | def get(self, k, d=None):
  function container_untake (line 100) | def container_untake(x, idx, vs):
  function sequence_extend_right (line 117) | def sequence_extend_right(seq, *elts):
  function grad_sequence_extend_right (line 121) | def grad_sequence_extend_right(argnum, ans, args, kwargs):
  function sequence_extend_left (line 130) | def sequence_extend_left(seq, *elts):
  function grad_sequence_extend_left (line 134) | def grad_sequence_extend_left(argnum, ans, args, kwargs):
  function make_sequence (line 143) | def make_sequence(seq_type, *args):
  function fwd_grad_make_sequence (line 150) | def fwd_grad_make_sequence(argnum, g, ans, seq_type, *args, **kwargs):
  class TupleMeta (line 157) | class TupleMeta(type(tuple_)):
    method __instancecheck__ (line 158) | def __instancecheck__(self, instance):
  class tuple (line 162) | class tuple(tuple_, metaclass=TupleMeta):
    method __new__ (line 163) | def __new__(cls, xs):
  class ListMeta (line 167) | class ListMeta(type_):
    method __instancecheck__ (line 168) | def __instancecheck__(self, instance):
  class list (line 172) | class list(list_, metaclass=ListMeta):
    method __new__ (line 173) | def __new__(cls, xs):
  class DictMeta (line 177) | class DictMeta(type_):
    method __instancecheck__ (line 178) | def __instancecheck__(self, instance):
  class dict (line 182) | class dict(dict_, metaclass=DictMeta):
    method __new__ (line 183) | def __new__(cls, *args, **kwargs):
  function _make_dict (line 191) | def _make_dict(keys, vals):
  class ContainerVSpace (line 198) | class ContainerVSpace(VSpace):
    method __init__ (line 199) | def __init__(self, value):
    method size (line 204) | def size(self):
    method zeros (line 207) | def zeros(self):
    method ones (line 210) | def ones(self):
    method randn (line 213) | def randn(self):
    method standard_basis (line 216) | def standard_basis(self):
    method _add (line 222) | def _add(self, xs, ys):
    method _mut_add (line 225) | def _mut_add(self, xs, ys):
    method _scalar_mul (line 228) | def _scalar_mul(self, xs, a):
    method _inner_prod (line 231) | def _inner_prod(self, xs, ys):
    method _covector (line 234) | def _covector(self, xs):
  class SequenceVSpace (line 238) | class SequenceVSpace(ContainerVSpace):
    method _values (line 239) | def _values(self, x):
    method _kv_pairs (line 242) | def _kv_pairs(self, x):
    method _map (line 245) | def _map(self, f, *args):
    method _subval (line 248) | def _subval(self, xs, idx, x):
  class ListVSpace (line 252) | class ListVSpace(SequenceVSpace):
  class TupleVSpace (line 256) | class TupleVSpace(SequenceVSpace):
  class DictVSpace (line 260) | class DictVSpace(ContainerVSpace):
    method _values (line 261) | def _values(self, x):
    method _kv_pairs (line 264) | def _kv_pairs(self, x):
    method _map (line 267) | def _map(self, f, *args):
    method _subval (line 270) | def _subval(self, xs, idx, x):
  class NamedTupleVSpace (line 281) | class NamedTupleVSpace(SequenceVSpace):
    method _map (line 282) | def _map(self, f, *args):
    method _subval (line 285) | def _subval(self, xs, idx, x):

FILE: autograd/core.py
  function make_vjp (line 10) | def make_vjp(fun, x):
  function backward_pass (line 25) | def backward_pass(g, end_node):
  class VJPNode (line 35) | class VJPNode(Node):
    method __init__ (line 38) | def __init__(self, value, fun, args, kwargs, parent_argnums, parents):
    method initialize_root (line 47) | def initialize_root(self):
  function defvjp_argnums (line 55) | def defvjp_argnums(fun, vjpmaker):
  function defvjp_argnum (line 59) | def defvjp_argnum(fun, vjpmaker):
  function defvjp (line 67) | def defvjp(fun, *vjpmakers, **kwargs):
  function translate_vjp (line 101) | def translate_vjp(vjpfun, fun, argnum):
  function make_jvp (line 113) | def make_jvp(fun, x):
  class JVPNode (line 125) | class JVPNode(Node):
    method __init__ (line 128) | def __init__(self, value, fun, args, kwargs, parent_argnums, parents):
    method initialize_root (line 137) | def initialize_root(self, g):
  function defjvp_argnums (line 144) | def defjvp_argnums(fun, jvpmaker):
  function defjvp_argnum (line 148) | def defjvp_argnum(fun, jvpmaker):
  function defjvp (line 155) | def defjvp(fun, *jvpfuns, **kwargs):
  function translate_jvp (line 165) | def translate_jvp(jvpfun, fun, argnum):
  function def_linear (line 176) | def def_linear(fun):
  function add_outgrads (line 184) | def add_outgrads(prev_g_flagged, g):
  function sum_outgrads (line 207) | def sum_outgrads(gs):
  function sparse_add (line 212) | def sparse_add(vs, x_prev, x_new):
  class VSpace (line 217) | class VSpace:
    method __init__ (line 222) | def __init__(self, value):
    method zeros (line 225) | def zeros(self):
    method ones (line 228) | def ones(self):
    method standard_basis (line 231) | def standard_basis(self):
    method randn (line 234) | def randn(self):
    method mut_add (line 238) | def mut_add(self, x_prev, x_new):
    method add (line 243) | def add(self, x_prev, x_new):
    method scalar_mul (line 247) | def scalar_mul(self, x, a):
    method inner_prod (line 251) | def inner_prod(self, x, y):
    method covector (line 255) | def covector(self, x):
    method _add (line 258) | def _add(self, x, y):
    method _mut_add (line 261) | def _mut_add(self, x, y):
    method _scalar_mul (line 265) | def _scalar_mul(self, x, a):
    method _inner_prod (line 268) | def _inner_prod(self, x, y):
    method _covector (line 271) | def _covector(self, x):
    method __eq__ (line 274) | def __eq__(self, other):
    method __repr__ (line 277) | def __repr__(self):
    method register (line 281) | def register(cls, value_type, vspace_maker=None):
  function vspace (line 288) | def vspace(value):
  class SparseBox (line 302) | class SparseBox(Box):
  class SparseObject (line 306) | class SparseObject:
    method __init__ (line 309) | def __init__(self, vs, mut_add):
  function deprecated_defvjp (line 358) | def deprecated_defvjp(primitive_fun):
  function deprecated_defvjp_is_zero (line 379) | def deprecated_defvjp_is_zero(primitive_fun):
  function deprecated_defgrad (line 392) | def deprecated_defgrad(primitive_fun):
  function primitive_with_deprecation_warnings (line 408) | def primitive_with_deprecation_warnings(f_raw):

FILE: autograd/differential_operators.py
  function grad (line 24) | def grad(fun, x):
  function elementwise_grad (line 40) | def elementwise_grad(fun, x):
  function deriv (line 53) | def deriv(fun, x):
  function jacobian (line 58) | def jacobian(fun, x):
  function holomorphic_grad (line 75) | def holomorphic_grad(fun, x):
  function grad_named (line 81) | def grad_named(fun, argname):
  function hessian (line 89) | def hessian(fun, x):
  function make_hvp (line 95) | def make_hvp(fun, x):
  function hessian_tensor_product (line 102) | def hessian_tensor_product(fun, argnum=0):
  function tensor_jacobian_product (line 118) | def tensor_jacobian_product(fun, argnum=0):
  function make_jvp_reversemode (line 134) | def make_jvp_reversemode(fun, x):
  function make_ggnvp (line 145) | def make_ggnvp(f, g=lambda x: 1.0 / 2 * np.sum(x**2, axis=-1), f_argnum=0):
  function value_and_grad (line 164) | def value_and_grad(fun, x):
  function grad_and_aux (line 178) | def grad_and_aux(fun, x):
  function multigrad_dict (line 185) | def multigrad_dict(fun):
  function checkpoint (line 230) | def checkpoint(fun):

FILE: autograd/misc/fixed_points.py
  function fixed_point (line 7) | def fixed_point(f, a, x0, distance, tol):
  function fixed_point_vjp (line 15) | def fixed_point_vjp(ans, f, a, x0, distance, tol):

FILE: autograd/misc/flatten.py
  function flatten (line 11) | def flatten(value):
  function _flatten (line 20) | def _flatten(value):
  function _concatenate (line 30) | def _concatenate(lst):
  function flatten_func (line 35) | def flatten_func(func, example):

FILE: autograd/misc/optimizers.py
  function unflatten_optimizer (line 15) | def unflatten_optimizer(optimize):
  function sgd (line 34) | def sgd(grad, x, callback=None, num_iters=200, step_size=0.1, mass=0.9):
  function rmsprop (line 48) | def rmsprop(grad, x, callback=None, num_iters=100, step_size=0.1, gamma=...
  function adam (line 61) | def adam(grad, x, callback=None, num_iters=100, step_size=0.001, b1=0.9,...

FILE: autograd/misc/tracers.py
  class ConstGraphNode (line 9) | class ConstGraphNode(Node):
    method __init__ (line 12) | def __init__(self, value, fun, args, kwargs, parent_argnums, parents):
    method initialize_root (line 21) | def initialize_root(self):
  function const_graph_unary (line 25) | def const_graph_unary(fun):
  function const_graph (line 47) | def const_graph(fun, *args, **kwargs):
  class FullGraphNode (line 59) | class FullGraphNode(Node):
    method __init__ (line 62) | def __init__(self, value, fun, args, kwargs, parent_argnums, parents):
    method initialize_root (line 66) | def initialize_root(self):
  function full_graph (line 71) | def full_graph(fun, *args, **kwargs):

FILE: autograd/numpy/fft.py
  function fft_grad (line 14) | def fft_grad(get_args, fft_fun, ans, x, *args, **kwargs):
  function rfft_grad (line 31) | def rfft_grad(get_args, irfft_fun, ans, x, *args, **kwargs):
  function irfft_grad (line 54) | def irfft_grad(get_args, rfft_fun, ans, x, *args, **kwargs):
  function truncate_pad (line 98) | def truncate_pad(x, shape):
  function check_no_repeated_axes (line 111) | def check_no_repeated_axes(axes):
  function check_even_shape (line 117) | def check_even_shape(shape):
  function get_fft_args (line 122) | def get_fft_args(a, d=None, axis=-1, norm=None, *args, **kwargs):
  function get_fft2_args (line 129) | def get_fft2_args(a, s=None, axes=(-2, -1), norm=None, *args, **kwargs):
  function get_fftn_args (line 133) | def get_fftn_args(a, s=None, axes=None, norm=None, *args, **kwargs):
  function make_rfft_factors (line 139) | def make_rfft_factors(axes, resshape, facshape, normshape, norm):

FILE: autograd/numpy/linalg.py
  function T (line 20) | def T(x):
  function _matrix_diag (line 31) | def _matrix_diag(a):
  function add2d (line 40) | def add2d(x):
  function grad_inv (line 48) | def grad_inv(ans, x):
  function grad_pinv (line 55) | def grad_pinv(ans, x):
  function grad_solve (line 67) | def grad_solve(argnum, ans, a, b):
  function norm_vjp (line 78) | def norm_vjp(ans, x, ord=None, axis=None):
  function norm_jvp (line 134) | def norm_jvp(g, ans, x, ord=None, axis=None):
  function grad_eigh (line 180) | def grad_eigh(ans, x, UPLO="L"):
  function grad_eig (line 221) | def grad_eig(ans, x):
  function grad_cholesky (line 247) | def grad_cholesky(L, A):
  function grad_svd (line 271) | def grad_svd(usv_, a, full_matrices=True, compute_uv=True):

FILE: autograd/numpy/numpy_boxes.py
  class ArrayBox (line 11) | class ArrayBox(Box):
    method __getitem__ (line 16) | def __getitem__(A, idx):
    method __array_namespace__ (line 26) | def __array_namespace__(self, *, api_version: str | None = None):
    method __len__ (line 29) | def __len__(self):
    method astype (line 32) | def astype(self, *args, **kwargs):
    method __neg__ (line 35) | def __neg__(self):
    method __add__ (line 38) | def __add__(self, other):
    method __sub__ (line 41) | def __sub__(self, other):
    method __mul__ (line 44) | def __mul__(self, other):
    method __pow__ (line 47) | def __pow__(self, other):
    method __div__ (line 50) | def __div__(self, other):
    method __mod__ (line 53) | def __mod__(self, other):
    method __truediv__ (line 56) | def __truediv__(self, other):
    method __matmul__ (line 59) | def __matmul__(self, other):
    method __radd__ (line 62) | def __radd__(self, other):
    method __rsub__ (line 65) | def __rsub__(self, other):
    method __rmul__ (line 68) | def __rmul__(self, other):
    method __rpow__ (line 71) | def __rpow__(self, other):
    method __rdiv__ (line 74) | def __rdiv__(self, other):
    method __rmod__ (line 77) | def __rmod__(self, other):
    method __rtruediv__ (line 80) | def __rtruediv__(self, other):
    method __rmatmul__ (line 83) | def __rmatmul__(self, other):
    method __eq__ (line 86) | def __eq__(self, other):
    method __ne__ (line 89) | def __ne__(self, other):
    method __gt__ (line 92) | def __gt__(self, other):
    method __ge__ (line 95) | def __ge__(self, other):
    method __lt__ (line 98) | def __lt__(self, other):
    method __le__ (line 101) | def __le__(self, other):
    method __abs__ (line 104) | def __abs__(self):
    method __hash__ (line 107) | def __hash__(self):

FILE: autograd/numpy/numpy_jvps.py
  function forward_grad_np_var (line 173) | def forward_grad_np_var(g, ans, x, axis=None, ddof=0, keepdims=False):
  function forward_grad_np_std (line 188) | def forward_grad_np_std(g, ans, x, axis=None, ddof=0, keepdims=False):
  function fwd_grad_chooser (line 205) | def fwd_grad_chooser(g, ans, x, axis=None, keepdims=False):
  function fwd_grad_concatenate_args (line 240) | def fwd_grad_concatenate_args(argnum, g, ans, axis_args, kwargs):
  function fwd_grad_sort (line 253) | def fwd_grad_sort(g, ans, x, axis=-1, kind="quicksort", order=None):
  function fwd_grad_partition (line 263) | def fwd_grad_partition(g, ans, x, kth, axis=-1, kind="introselect", orde...
  function atleast_jvpmaker (line 271) | def atleast_jvpmaker(fun):
  function broadcast (line 288) | def broadcast(x, target):

FILE: autograd/numpy/numpy_vjps.py
  function grad_rollaxis (line 255) | def grad_rollaxis(ans, a, axis, start=0):
  function grad_diff (line 270) | def grad_diff(ans, a, n=1, axis=-1):
  function grad_gradient (line 297) | def grad_gradient(ans, x, *vargs, **kwargs):
  function grad_repeat (line 345) | def grad_repeat(ans, x, repeats, axis=None):
  function grad_tile (line 365) | def grad_tile(ans, x, reps):
  function grad_kron (line 380) | def grad_kron(argnum, ans, orig_A, orig_B):
  function grad_transpose (line 407) | def grad_transpose(ans, x, axes=None):
  function repeat_to_match_shape (line 416) | def repeat_to_match_shape(g, shape, dtype, axis, keepdims):
  function grad_broadcast_to (line 430) | def grad_broadcast_to(ans, x, new_shape):
  function grad_np_sum (line 443) | def grad_np_sum(ans, x, axis=None, keepdims=False, dtype=None):
  function grad_np_mean (line 451) | def grad_np_mean(ans, x, axis=None, keepdims=False):
  function grad_np_prod (line 464) | def grad_np_prod(ans, x, axis=None, keepdims=False):  # TODO: Support tu...
  function grad_np_var (line 477) | def grad_np_var(ans, x, axis=None, ddof=0, keepdims=False):
  function grad_np_std (line 493) | def grad_np_std(ans, x, axis=None, ddof=0, keepdims=False):
  function grad_chooser (line 515) | def grad_chooser(ans, x, axis=None, keepdims=None):
  function reverse_axis (line 533) | def reverse_axis(x, axis):
  function grad_np_cumsum (line 539) | def grad_np_cumsum(ans, x, axis=None):
  function grad_inner (line 552) | def grad_inner(argnum, ans, A, B):
  function matmul_adjoint_0 (line 567) | def matmul_adjoint_0(B, G, A_meta, B_ndim):
  function matmul_adjoint_1 (line 582) | def matmul_adjoint_1(A, G, A_ndim, B_meta):
  function matmul_vjp_0 (line 600) | def matmul_vjp_0(ans, A, B):
  function matmul_vjp_1 (line 606) | def matmul_vjp_1(ans, A, B):
  function dot_adjoint_0 (line 616) | def dot_adjoint_0(B, G, A_meta, B_meta):
  function dot_adjoint_1 (line 628) | def dot_adjoint_1(A, G, A_meta, B_meta):
  function dot_vjp_0 (line 641) | def dot_vjp_0(ans, A, B):
  function dot_vjp_1 (line 646) | def dot_vjp_1(ans, A, B):
  function tensordot_adjoint_0 (line 667) | def tensordot_adjoint_0(B, G, axes, A_ndim, B_ndim):
  function tensordot_adjoint_1 (line 695) | def tensordot_adjoint_1(A, G, axes, A_ndim, B_ndim):
  function tensordot_vjp_0 (line 722) | def tensordot_vjp_0(ans, A, B, axes=2):
  function tensordot_vjp_1 (line 727) | def tensordot_vjp_1(ans, A, B, axes=2):
  function grad_concatenate_args (line 750) | def grad_concatenate_args(argnum, ans, axis_args, kwargs):
  function wrapped_reshape (line 762) | def wrapped_reshape(x, *args, **kwargs):
  function grad_sort (line 774) | def grad_sort(ans, x, axis=-1, kind="quicksort", order=None):
  function grad_partition (line 787) | def grad_partition(ans, x, kth, axis=-1, kind="introselect", order=None):
  function unpermuter (line 798) | def unpermuter(g, permutation):
  function grad_reshape_list (line 804) | def grad_reshape_list(ans, *arys):
  function grad_einsum (line 815) | def grad_einsum(argnum, ans, operands_, kwargs):
  function match_complex (line 872) | def match_complex(target, x):
  function unbroadcast (line 883) | def unbroadcast(x, target_meta, broadcast_idx=0):
  function unbroadcast_f (line 895) | def unbroadcast_f(target, f):
  function unbroadcast_einsum (line 900) | def unbroadcast_einsum(x, target_meta, subscript):
  function balanced_eq (line 911) | def balanced_eq(x, z, y):
  function replace_zero (line 915) | def replace_zero(x, val):
  function array_from_args_gradmaker (line 922) | def array_from_args_gradmaker(argnum, ans, args, kwargs):
  function array_from_scalar_or_array_gradmaker (line 929) | def array_from_scalar_or_array_gradmaker(ans, array_args, array_kwargs, ...
  function untake (line 942) | def untake(x, idx, vs):
  function _unpad (line 957) | def _unpad(array, width):
  function pad_vjp (line 970) | def pad_vjp(ans, array, pad_width, mode, **kwargs):

FILE: autograd/numpy/numpy_vspaces.py
  class ArrayVSpace (line 7) | class ArrayVSpace(VSpace):
    method __init__ (line 8) | def __init__(self, value):
    method size (line 14) | def size(self):
    method ndim (line 18) | def ndim(self):
    method zeros (line 21) | def zeros(self):
    method ones (line 24) | def ones(self):
    method standard_basis (line 27) | def standard_basis(self):
    method randn (line 33) | def randn(self):
    method _inner_prod (line 36) | def _inner_prod(self, x, y):
  class ComplexArrayVSpace (line 40) | class ComplexArrayVSpace(ArrayVSpace):
    method size (line 44) | def size(self):
    method ones (line 47) | def ones(self):
    method standard_basis (line 50) | def standard_basis(self):
    method randn (line 57) | def randn(self):
    method _inner_prod (line 62) | def _inner_prod(self, x, y):
    method _covector (line 65) | def _covector(self, x):
  class EigResultVSpace (line 80) | class EigResultVSpace(NamedTupleVSpace):
  class EighResultVSpace (line 83) | class EighResultVSpace(NamedTupleVSpace):
  class QRResultVSpace (line 86) | class QRResultVSpace(NamedTupleVSpace):
  class SlogdetResultVSpace (line 89) | class SlogdetResultVSpace(NamedTupleVSpace):
  class SVDResultVSpace (line 92) | class SVDResultVSpace(NamedTupleVSpace):
  class EigResultVSpace (line 102) | class EigResultVSpace(NamedTupleVSpace):
  class EighResultVSpace (line 105) | class EighResultVSpace(NamedTupleVSpace):
  class QRResultVSpace (line 108) | class QRResultVSpace(NamedTupleVSpace):
  class SlogdetResultVSpace (line 111) | class SlogdetResultVSpace(NamedTupleVSpace):
  class SVDResultVSpace (line 114) | class SVDResultVSpace(NamedTupleVSpace):

FILE: autograd/numpy/numpy_wrapper.py
  function wrap_intdtype (line 18) | def wrap_intdtype(cls):
  function wrap_namespace (line 25) | def wrap_namespace(old, new):
  function concatenate_args (line 45) | def concatenate_args(axis, *args):
  function hstack (line 53) | def hstack(tup):
  function column_stack (line 60) | def column_stack(tup):
  function array (line 70) | def array(A, *args, **kwargs):
  function wrap_if_boxes_inside (line 78) | def wrap_if_boxes_inside(raw_array, slow_op_name=None):
  function _array_from_scalar_or_array (line 88) | def _array_from_scalar_or_array(array_args, array_kwargs, scalar):
  function array_from_args (line 93) | def array_from_args(array_args, array_kwargs, *args):
  function select (line 97) | def select(condlist, choicelist, default=0):
  function stack (line 102) | def stack(arrays, axis=0):
  function append (line 125) | def append(arr, values, axis=None):
  class r_class (line 139) | class r_class:
    method __getitem__ (line 140) | def __getitem__(self, args):
  class c_class (line 148) | class c_class:
    method __getitem__ (line 149) | def __getitem__(self, args):
  function make_diagonal (line 159) | def make_diagonal(D, offset=0, axis1=0, axis2=1):
  function metadata (line 176) | def metadata(A):
  function parse_einsum_input (line 181) | def parse_einsum_input(*args):
  function _astype (line 191) | def _astype(A, dtype, order="K", casting="unsafe", subok=True, copy=True):

FILE: autograd/scipy/integrate.py
  function grad_odeint (line 12) | def grad_odeint(yt, func, y0, t, func_args, **kwargs):
  function argnums_unpack (line 65) | def argnums_unpack(all_vjp_builder):

FILE: autograd/scipy/linalg.py
  function _vjp_sqrtm (line 12) | def _vjp_sqrtm(ans, A, disp=True, blocksize=64):
  function _flip (line 25) | def _flip(a, trans):
  function grad_solve_triangular (line 32) | def grad_solve_triangular(ans, a, b, trans=0, lower=False, **kwargs):
  function grad_solve_banded (line 53) | def grad_solve_banded(argnum, ans, l_and_u, a, b):
  function _jvp_sqrtm (line 107) | def _jvp_sqrtm(dA, ans, A, disp=True, blocksize=64):
  function _jvp_sylvester (line 115) | def _jvp_sylvester(argnums, dms, ans, args, _):
  function _vjp_sylvester (line 131) | def _vjp_sylvester(argnums, ans, args, _):

FILE: autograd/scipy/signal.py
  function convolve (line 11) | def convolve(A, B, axes=None, dot_axes=[(), ()], mode="full"):
  function einsum_tensordot (line 46) | def einsum_tensordot(A, B, axes, reverse=False):
  function pad_to_full (line 57) | def pad_to_full(A, B, axes):
  function parse_axes (line 64) | def parse_axes(A_shape, B_shape, conv_axes, dot_axes, mode):
  function compute_conv_size (line 108) | def compute_conv_size(A_size, B_size, mode):
  function flipped_idxs (line 119) | def flipped_idxs(ndim, axes):
  function grad_convolve (line 126) | def grad_convolve(argnum, ans, A, B, axes=None, dot_axes=[(), ()], mode=...

FILE: autograd/scipy/special.py
  function make_gammainc_vjp_arg1 (line 56) | def make_gammainc_vjp_arg1(sign):
  function make_grad_logsumexp (line 123) | def make_grad_logsumexp(ans, x, axis=None, b=1.0, keepdims=False):
  function fwd_grad_logsumexp (line 137) | def fwd_grad_logsumexp(g, ans, x, axis=None, b=1.0, keepdims=False):

FILE: autograd/scipy/stats/beta.py
  function grad_beta_logpdf_arg0 (line 13) | def grad_beta_logpdf_arg0(x, a, b):
  function grad_beta_logpdf_arg1 (line 17) | def grad_beta_logpdf_arg1(x, a, b):
  function grad_beta_logpdf_arg2 (line 21) | def grad_beta_logpdf_arg2(x, a, b):

FILE: autograd/scipy/stats/chi2.py
  function grad_chi2_logpdf (line 13) | def grad_chi2_logpdf(x, df):

FILE: autograd/scipy/stats/gamma.py
  function grad_gamma_logpdf_arg0 (line 13) | def grad_gamma_logpdf_arg0(x, a):
  function grad_gamma_logpdf_arg1 (line 17) | def grad_gamma_logpdf_arg1(x, a):

FILE: autograd/scipy/stats/multivariate_normal.py
  function generalized_outer_product (line 19) | def generalized_outer_product(x):
  function covgrad (line 25) | def covgrad(x, mean, cov, allow_singular=False):
  function solve (line 35) | def solve(allow_singular):

FILE: autograd/scipy/stats/poisson.py
  function grad_poisson_logpmf (line 12) | def grad_poisson_logpmf(k, mu):

FILE: autograd/scipy/stats/t.py
  function grad_tlogpdf_diff (line 16) | def grad_tlogpdf_diff(diff, df):
  function grad_tlogpdf_x (line 20) | def grad_tlogpdf_x(x, df, loc, scale):
  function grad_tlogpdf_loc (line 24) | def grad_tlogpdf_loc(x, df, loc, scale):
  function grad_tlogpdf_scale (line 28) | def grad_tlogpdf_scale(x, df, loc, scale):
  function grad_tlogpdf_df (line 33) | def grad_tlogpdf_df(x, df, loc, scale):

FILE: autograd/test_util.py
  function scalar_close (line 10) | def scalar_close(a, b):
  function make_numerical_jvp (line 17) | def make_numerical_jvp(f, x):
  function check_vjp (line 31) | def check_vjp(f, x):
  function check_jvp (line 48) | def check_jvp(f, x):
  function check_equivalent (line 55) | def check_equivalent(x, y):
  function check_grads (line 63) | def check_grads(f, x, modes=["fwd", "rev"], order=2):
  function combo_check (line 81) | def combo_check(fun, *args, **kwargs):

FILE: autograd/tracer.py
  function trace (line 9) | def trace(start_node, fun, x):
  class Node (line 20) | class Node:
    method __init__ (line 23) | def __init__(self, value, fun, args, kwargs, parent_argnums, parents):
    method initialize_root (line 26) | def initialize_root(self, *args, **kwargs):
    method new_root (line 30) | def new_root(cls, *args, **kwargs):
  function primitive (line 36) | def primitive(f_raw):
  function register_notrace (line 64) | def register_notrace(trace_type, primitive_fun):
  function notrace_primitive (line 68) | def notrace_primitive(f_raw):
  function find_top_boxed_args (line 78) | def find_top_boxed_args(args):
  class TraceStack (line 94) | class TraceStack:
    method __init__ (line 95) | def __init__(self):
    method new_trace (line 99) | def new_trace(self):
  class Box (line 108) | class Box:
    method __init__ (line 114) | def __init__(self, value, trace, node):
    method __bool__ (line 119) | def __bool__(self):
    method __str__ (line 124) | def __str__(self):
    method register (line 128) | def register(cls, value_type):
  function new_box (line 137) | def new_box(value, trace, node):

FILE: autograd/util.py
  function subvals (line 4) | def subvals(x, ivs):
  function subval (line 11) | def subval(x, i, v):
  function func (line 17) | def func(f):
  function toposort (line 21) | def toposort(end_node, parents=operator.attrgetter("parents")):
  function quick_grad_check (line 52) | def quick_grad_check(

FILE: autograd/wrap_util.py
  function unary_to_nary (line 4) | def unary_to_nary(unary_operator):
  function wraps (line 30) | def wraps(fun, namestr="{fun}", docstr="{doc}", **kwargs):
  function wrap_nary_f (line 42) | def wrap_nary_f(fun, op, argnum):

FILE: benchmarks/bench_core.py
  function f_short (line 18) | def f_short(x):
  function time_short_fun (line 22) | def time_short_fun():
  function time_short_forward_pass (line 26) | def time_short_forward_pass():
  function time_short_backward_pass (line 34) | def time_short_backward_pass():
  function time_short_grad (line 41) | def time_short_grad():
  function f_long (line 46) | def f_long(x):
  function time_long_fun (line 52) | def time_long_fun():
  function time_long_forward_pass (line 56) | def time_long_forward_pass():
  function time_long_backward_pass (line 64) | def time_long_backward_pass():
  function time_long_grad (line 71) | def time_long_grad():
  function fan_out_fan_in (line 76) | def fan_out_fan_in(x):
  function time_fan_out_fan_in_fun (line 82) | def time_fan_out_fan_in_fun():
  function time_fan_out_fan_in_forward_pass (line 86) | def time_fan_out_fan_in_forward_pass():
  function time_fan_out_fan_in_backward_pass (line 94) | def time_fan_out_fan_in_backward_pass():
  function time_fan_out_fan_in_grad (line 101) | def time_fan_out_fan_in_grad():
  function time_vspace_float (line 106) | def time_vspace_float():
  function time_vspace_array (line 113) | def time_vspace_array():
  function time_new_box_float (line 117) | def time_new_box_float():
  function time_new_box_array (line 121) | def time_new_box_array():
  function time_exp_call (line 125) | def time_exp_call():
  function time_exp_primitive_call_unboxed (line 129) | def time_exp_primitive_call_unboxed():
  function time_exp_primitive_call_boxed (line 133) | def time_exp_primitive_call_boxed():
  function time_no_autograd_control (line 140) | def time_no_autograd_control():

FILE: benchmarks/bench_mem.py
  function peakmem_needless_nodes (line 5) | def peakmem_needless_nodes():

FILE: benchmarks/bench_numpy_vjps.py
  function time_dot_0 (line 21) | def time_dot_0():
  function time_dot_1 (line 25) | def time_dot_1():
  function time_dot_0_0 (line 29) | def time_dot_0_0():
  function time_dot_0_1 (line 33) | def time_dot_0_1():
  function time_dot_0_2 (line 37) | def time_dot_0_2():
  function time_dot_1_0 (line 41) | def time_dot_1_0():
  function time_dot_1_1 (line 45) | def time_dot_1_1():
  function time_dot_1_2 (line 49) | def time_dot_1_2():
  function time_tensordot_0 (line 69) | def time_tensordot_0():
  function time_tensordot_1 (line 73) | def time_tensordot_1():
  function time_tensordot_0_0 (line 77) | def time_tensordot_0_0():
  function time_tensordot_0_1 (line 81) | def time_tensordot_0_1():
  function time_tensordot_0_2 (line 85) | def time_tensordot_0_2():
  function time_tensordot_1_0 (line 89) | def time_tensordot_1_0():
  function time_tensordot_1_1 (line 93) | def time_tensordot_1_1():
  function time_tensordot_1_2 (line 97) | def time_tensordot_1_2():

FILE: benchmarks/bench_rnn.py
  class RNNSuite (line 8) | class RNNSuite:
    method setup (line 15) | def setup(self):
    method rnn_grad (line 39) | def rnn_grad(self):
    method time_rnn_grad (line 42) | def time_rnn_grad(self):
    method peakmem_rnn_grad (line 45) | def peakmem_rnn_grad(self):
    method time_manual_rnn_grad (line 48) | def time_manual_rnn_grad(self):
    method peakmem_manual_rnn_grad (line 51) | def peakmem_manual_rnn_grad(self):
    method manual_rnn_grad (line 54) | def manual_rnn_grad(self):

FILE: benchmarks/bench_util.py
  function time_flatten (line 11) | def time_flatten():
  function time_grad_flatten (line 37) | def time_grad_flatten():

FILE: examples/bayesian_neural_net.py
  function make_nn_funs (line 9) | def make_nn_funs(layer_sizes, L2_reg, noise_variance, nonlinearity=np.ta...
  function build_toy_dataset (line 42) | def build_toy_dataset(n_data=40, noise_std=0.1):
  function callback (line 75) | def callback(params, t, g):

FILE: examples/bayesian_optimization.py
  function probability_of_improvement (line 14) | def probability_of_improvement(mean, std, max_so_far):
  function expected_new_max (line 18) | def expected_new_max(mean, std, max_so_far):
  function init_covariance_params (line 26) | def init_covariance_params(num_params):
  function defaultmax (line 30) | def defaultmax(x, default=-np.inf):
  function bayesian_optimize (line 36) | def bayesian_optimize(func, domain_min, domain_max, num_iters=20, callba...
  function example_function (line 110) | def example_function(x):
  function callback (line 121) | def callback(X, y, predict_func, acquisition_function, next_point, new_v...

FILE: examples/black_box_svi.py
  function black_box_variational_inference (line 11) | def black_box_variational_inference(logprob, D, num_samples):
  function log_density (line 41) | def log_density(x, t):
  function plot_isocontours (line 51) | def plot_isocontours(ax, func, xlimits=[-2, 2], ylimits=[-4, 2], numtick...
  function callback (line 67) | def callback(params, t, g):

FILE: examples/convnet.py
  class WeightsParser (line 14) | class WeightsParser:
    method __init__ (line 17) | def __init__(self):
    method add_weights (line 21) | def add_weights(self, name, shape):
    method get (line 26) | def get(self, vect, name):
  function make_batches (line 31) | def make_batches(N_total, N_batch):
  function logsumexp (line 40) | def logsumexp(X, axis, keepdims=False):
  function make_nn_funs (line 45) | def make_nn_funs(input_shape, layer_specs, L2_reg):
  class conv_layer (line 72) | class conv_layer:
    method __init__ (line 73) | def __init__(self, kernel_shape, num_filters):
    method forward_pass (line 77) | def forward_pass(self, inputs, param_vector):
    method build_weights_dict (line 86) | def build_weights_dict(self, input_shape):
    method conv_output_shape (line 94) | def conv_output_shape(self, A, B):
  class maxpool_layer (line 98) | class maxpool_layer:
    method __init__ (line 99) | def __init__(self, pool_shape):
    method build_weights_dict (line 102) | def build_weights_dict(self, input_shape):
    method forward_pass (line 110) | def forward_pass(self, inputs, param_vector):
  class full_layer (line 120) | class full_layer:
    method __init__ (line 121) | def __init__(self, size):
    method build_weights_dict (line 124) | def build_weights_dict(self, input_shape):
    method forward_pass (line 132) | def forward_pass(self, inputs, param_vector):
  class tanh_layer (line 140) | class tanh_layer(full_layer):
    method nonlinearity (line 141) | def nonlinearity(self, x):
  class softmax_layer (line 145) | class softmax_layer(full_layer):
    method nonlinearity (line 146) | def nonlinearity(self, x):
  function print_perf (line 195) | def print_perf(epoch, W):

FILE: examples/data.py
  function load_mnist (line 9) | def load_mnist():
  function plot_images (line 22) | def plot_images(
  function save_images (line 58) | def save_images(images, filename, **kwargs):
  function make_pinwheel (line 68) | def make_pinwheel(radial_std, tangential_std, num_classes, num_per_class...

FILE: examples/data_mnist.py
  function download (line 10) | def download(url, filename):
  function mnist (line 18) | def mnist():

FILE: examples/deep_gaussian_process.py
  function build_step_function_dataset (line 10) | def build_step_function_dataset(D=1, n_data=40, noise_std=0.1):
  function build_deep_gp (line 18) | def build_deep_gp(input_dimension, hidden_dimension, covariance_function):
  function plot_gp (line 84) | def plot_gp(ax, X, y, pred_mean, pred_cov, plot_xs):
  function callback (line 105) | def callback(params):

FILE: examples/define_gradient.py
  function logsumexp (line 17) | def logsumexp(x):
  function logsumexp_vjp (line 29) | def logsumexp_vjp(ans, x):
  function example_func (line 47) | def example_func(y):

FILE: examples/dot_graph.py
  class GraphNode (line 11) | class GraphNode(Node):
    method __init__ (line 13) | def __init__(self, value, fun, args, kwargs, parent_argnums, parents):
    method initialize_root (line 19) | def initialize_root(self, x):
    method __repr__ (line 22) | def __repr__(self):
  function trace_graph (line 26) | def trace_graph(f, x):
  function graph_to_dotfile (line 38) | def graph_to_dotfile(graph):
  function fun (line 67) | def fun(x):

FILE: examples/fixed_points.py
  function newton_sqrt_iter (line 6) | def newton_sqrt_iter(a):
  function grad_descent_sqrt_iter (line 10) | def grad_descent_sqrt_iter(a):
  function sqrt (line 14) | def sqrt(a, guess=10.0):
  function distance (line 19) | def distance(x, y):

FILE: examples/fluidsim/fluidsim.py
  function project (line 16) | def project(vx, vy):
  function advect (line 46) | def advect(f, vx, vy):
  function simulate (line 71) | def simulate(vx, vy, smoke, num_time_steps, ax=None, render=False):
  function plot_matrix (line 85) | def plot_matrix(ax, mat, t, render=False):
  function distance_from_target_image (line 108) | def distance_from_target_image(smoke):
  function convert_param_vector_to_matrices (line 111) | def convert_param_vector_to_matrices(params):
  function objective (line 116) | def objective(params):
  function callback (line 127) | def callback(params):

FILE: examples/fluidsim/wing.py
  function occlude (line 16) | def occlude(f, occlusion):
  function project (line 20) | def project(vx, vy, occlusion):
  function advect (line 47) | def advect(f, vx, vy):
  function make_continuous (line 72) | def make_continuous(f, occlusion):
  function sigmoid (line 89) | def sigmoid(x):
  function simulate (line 93) | def simulate(vx, vy, num_time_steps, occlusion, ax=None, render=False):
  function plot_matrix (line 122) | def plot_matrix(ax, r, g, b, t, render=False):
  function drag (line 146) | def drag(vx):
  function lift (line 149) | def lift(vy):
  function objective (line 152) | def objective(params):
  function callback (line 163) | def callback(weights):

FILE: examples/gaussian_process.py
  function make_gp_funs (line 11) | def make_gp_funs(cov_func, num_cov_params):
  function rbf_covariance (line 42) | def rbf_covariance(kernel_params, x, xp):
  function build_toy_dataset (line 49) | def build_toy_dataset(D=1, n_data=20, noise_std=0.1):
  function callback (line 72) | def callback(params):

FILE: examples/generative_adversarial_net.py
  function relu (line 16) | def relu(x):
  function sigmoid (line 20) | def sigmoid(x):
  function logsigmoid (line 24) | def logsigmoid(x):
  function init_random_params (line 28) | def init_random_params(scale, layer_sizes, rs=npr.RandomState(0)):
  function batch_normalize (line 40) | def batch_normalize(activations):
  function neural_net_predict (line 45) | def neural_net_predict(params, inputs):
  function generate_from_noise (line 58) | def generate_from_noise(gen_params, num_samples, noise_dim, rs):
  function gan_objective (line 64) | def gan_objective(gen_params, dsc_params, real_data, num_samples, noise_...
  function adam_minimax (line 74) | def adam_minimax(
  function batch_indices (line 143) | def batch_indices(iter):
  function objective (line 150) | def objective(gen_params, dsc_params, iter):
  function print_perf (line 159) | def print_perf(gen_params, dsc_params, iter, gen_gradient, dsc_gradient):

FILE: examples/gmm.py
  function init_gmm_params (line 17) | def init_gmm_params(num_components, D, scale, rs=npr.RandomState(0)):
  function log_normalize (line 25) | def log_normalize(x):
  function unpack_gmm_params (line 29) | def unpack_gmm_params(params):
  function gmm_log_likelihood (line 34) | def gmm_log_likelihood(params, data):
  function plot_ellipse (line 42) | def plot_ellipse(ax, mean, cov_sqrt, alpha, num_points=100):
  function plot_gaussian_mixture (line 49) | def plot_gaussian_mixture(params, ax):
  function objective (line 60) | def objective(params):
  function callback (line 69) | def callback(flattened_params):

FILE: examples/gplvm.py
  function unpack_params (line 39) | def unpack_params(params):
  function objective (line 44) | def objective(params):
  function callback (line 58) | def callback(params):

FILE: examples/hmm_em.py
  function EM (line 11) | def EM(init_params, data, callback=None):
  function normalize (line 32) | def normalize(a):
  function log_partition_function (line 39) | def log_partition_function(natural_params, data):
  function initialize_hmm_parameters (line 52) | def initialize_hmm_parameters(num_states, num_outputs):
  function build_dataset (line 59) | def build_dataset(filename, max_lines=-1):

FILE: examples/ica.py
  function make_ica_funs (line 11) | def make_ica_funs(observed_dimension, latent_dimension):
  function color_scatter (line 42) | def color_scatter(ax, xs, ys):
  function unpack_params (line 59) | def unpack_params(params):
  function objective (line 95) | def objective(params):
  function callback (line 99) | def callback(params):

FILE: examples/logistic_regression.py
  function sigmoid (line 6) | def sigmoid(x):
  function logistic_predictions (line 10) | def logistic_predictions(weights, inputs):
  function training_loss (line 15) | def training_loss(weights):

FILE: examples/lstm.py
  function init_lstm_params (line 16) | def init_lstm_params(input_size, state_size, output_size, param_scale=0....
  function lstm_predict (line 31) | def lstm_predict(params, inputs):
  function lstm_log_likelihood (line 56) | def lstm_log_likelihood(params, inputs, targets):
  function print_training_prediction (line 74) | def print_training_prediction(weights):
  function training_loss (line 82) | def training_loss(params, iter):
  function callback (line 85) | def callback(weights, iter, gradient):

FILE: examples/mixture_variational_inference.py
  function diag_gaussian_log_density (line 17) | def diag_gaussian_log_density(x, mu, log_std):
  function unpack_gaussian_params (line 21) | def unpack_gaussian_params(params):
  function variational_log_density_gaussian (line 28) | def variational_log_density_gaussian(params, x):
  function sample_diag_gaussian (line 33) | def sample_diag_gaussian(params, num_samples, rs):
  function variational_lower_bound (line 39) | def variational_lower_bound(params, t, logprob, sampler, log_density, nu...
  function init_gaussian_var_params (line 50) | def init_gaussian_var_params(D, mean_mean=-1, log_std_mean=-5, scale=0.1...
  function log_normalize (line 56) | def log_normalize(x):
  function build_mog_bbsvi (line 60) | def build_mog_bbsvi(logprob, num_samples, k=10, rs=npr.RandomState(0)):
  function log_density (line 118) | def log_density(x, t):
  function objective (line 130) | def objective(params, t):
  function plot_isocontours (line 134) | def plot_isocontours(ax, func, xlimits=[-2, 2], ylimits=[-4, 2], numtick...
  function callback (line 151) | def callback(params, t, g):

FILE: examples/natural_gradient_black_box_svi.py
  function log_density (line 18) | def log_density(x, t):
  function fisher_diag (line 47) | def fisher_diag(lam):
  function optimize_and_lls (line 55) | def optimize_and_lls(optfun):

FILE: examples/negative_binomial_maxlike.py
  function newton (line 13) | def newton(f, x0):
  function negbin_loglike (line 18) | def negbin_loglike(r, p, x):
  function negbin_sample (line 23) | def negbin_sample(r, p, size):
  function fit_maxlike (line 28) | def fit_maxlike(x, r_guess):

FILE: examples/neural_net.py
  function init_random_params (line 13) | def init_random_params(scale, layer_sizes, rs=npr.RandomState(0)):
  function neural_net_predict (line 25) | def neural_net_predict(params, inputs):
  function l2_norm (line 36) | def l2_norm(params):
  function log_posterior (line 42) | def log_posterior(params, inputs, targets, L2_reg):
  function accuracy (line 48) | def accuracy(params, inputs, targets):
  function batch_indices (line 72) | def batch_indices(iter):
  function objective (line 77) | def objective(params, iter):
  function print_perf (line 86) | def print_perf(params, iter, gradient):

FILE: examples/neural_net_regression.py
  function init_random_params (line 11) | def init_random_params(scale, layer_sizes, rs=npr.RandomState(0)):
  function nn_predict (line 22) | def nn_predict(params, inputs, nonlinearity=np.tanh):
  function log_gaussian (line 29) | def log_gaussian(params, scale):
  function logprob (line 34) | def logprob(weights, inputs, targets, noise_scale=0.1):
  function build_toy_dataset (line 39) | def build_toy_dataset(n_data=80, noise_std=0.1):
  function objective (line 56) | def objective(weights, t):
  function callback (line 66) | def callback(params, t, g):

FILE: examples/ode_net.py
  function func (line 21) | def func(y, t0, A):
  function nn_predict (line 25) | def nn_predict(inputs, t, params):
  function init_nn_params (line 32) | def init_nn_params(scale, layer_sizes, rs=npr.RandomState(0)):
  function ode_pred (line 44) | def ode_pred(params, y0, t):
  function L1_loss (line 48) | def L1_loss(pred, targets):
  function train_loss (line 59) | def train_loss(params, iter):
  function callback (line 71) | def callback(params, iter, g):

FILE: examples/print_trace.py
  class PrintNode (line 9) | class PrintNode(Node):
    method __init__ (line 10) | def __init__(self, value, fun, args, kwargs, parent_argnums, parents):
    method initialize_root (line 18) | def initialize_root(self, x):
  function make_varname_generator (line 24) | def make_varname_generator():
  function print_trace (line 30) | def print_trace(f, x):
  function avg (line 36) | def avg(x, y):
  function fun (line 40) | def fun(x):

FILE: examples/rkhs.py
  class RKHSFun (line 15) | class RKHSFun:
    method __init__ (line 16) | def __init__(self, kernel, alphas={}):
    method __call__ (line 22) | def __call__(self, x):
    method __add__ (line 25) | def __add__(self, f):
    method __mul__ (line 28) | def __mul__(self, a):
  class RKHSFunBox (line 36) | class RKHSFunBox(Box, RKHSFun):
    method kernel (line 38) | def kernel(self):
  class RKHSFunVSpace (line 45) | class RKHSFunVSpace(VSpace):
    method __init__ (line 46) | def __init__(self, value):
    method zeros (line 49) | def zeros(self):
    method randn (line 52) | def randn(self):
    method _add (line 57) | def _add(self, f, g):
    method _scalar_mul (line 61) | def _scalar_mul(self, f, a):
    method _inner_prod (line 64) | def _inner_prod(self, f, g):
  function add_dicts (line 74) | def add_dicts(d1, d2):
  function sq_exp_kernel (line 83) | def sq_exp_kernel(x1, x2):
  function logprob (line 89) | def logprob(f, xs, ys):

FILE: examples/rnn.py
  function sigmoid (line 16) | def sigmoid(x):
  function concat_and_multiply (line 20) | def concat_and_multiply(weights, *args):
  function create_rnn_params (line 28) | def create_rnn_params(input_size, state_size, output_size, param_scale=0...
  function rnn_predict (line 36) | def rnn_predict(params, inputs):
  function rnn_log_likelihood (line 54) | def rnn_log_likelihood(params, inputs, targets):
  function string_to_one_hot (line 66) | def string_to_one_hot(string, maxchar):
  function one_hot_to_string (line 72) | def one_hot_to_string(one_hot_matrix):
  function build_dataset (line 76) | def build_dataset(filename, sequence_length, alphabet_size, max_lines=-1):
  function print_training_prediction (line 98) | def print_training_prediction(weights):
  function training_loss (line 106) | def training_loss(params, iter):
  function callback (line 109) | def callback(weights, iter, gradient):

FILE: examples/rosenbrock.py
  function rosenbrock (line 7) | def rosenbrock(x):

FILE: examples/sinusoid.py
  function fun (line 7) | def fun(x):
  function fun (line 25) | def fun(x):

FILE: examples/tanh.py
  function tanh (line 22) | def tanh(x):

FILE: examples/variational_autoencoder.py
  function diag_gaussian_log_density (line 13) | def diag_gaussian_log_density(x, mu, log_std):
  function unpack_gaussian_params (line 17) | def unpack_gaussian_params(params):
  function sample_diag_gaussian (line 24) | def sample_diag_gaussian(mean, log_std, rs):
  function bernoulli_log_density (line 28) | def bernoulli_log_density(targets, unnormalized_logprobs):
  function relu (line 35) | def relu(x):
  function init_net_params (line 39) | def init_net_params(scale, layer_sizes, rs=npr.RandomState(0)):
  function batch_normalize (line 50) | def batch_normalize(activations):
  function neural_net_predict (line 55) | def neural_net_predict(params, inputs):
  function nn_predict_gaussian (line 67) | def nn_predict_gaussian(params, inputs):
  function generate_from_prior (line 72) | def generate_from_prior(gen_params, num_samples, noise_dim, rs):
  function p_images_given_latents (line 77) | def p_images_given_latents(gen_params, images, latents):
  function vae_lower_bound (line 82) | def vae_lower_bound(gen_params, rec_params, data, rs):
  function binarise (line 109) | def binarise(images):
  function batch_indices (line 125) | def batch_indices(iter):
  function objective (line 132) | def objective(combined_params, iter):
  function print_perf (line 142) | def print_perf(combined_params, iter, grad):

FILE: noxfile.py
  function check (line 21) | def check(session):
  function run_tests (line 29) | def run_tests(session):
  function ruff (line 42) | def ruff(session):
  function run_nightly_tests (line 49) | def run_nightly_tests(session):

FILE: tests/_test_complexity.py
  function timefunction (line 9) | def timefunction(f):
  function assert_linear_time (line 15) | def assert_linear_time(f):
  function test_array_creation (line 24) | def test_array_creation():
  function test_array_indexing (line 32) | def test_array_indexing():
  function test_list_indexing (line 39) | def test_list_indexing():
  function test_list_creation (line 46) | def test_list_creation():
  function test_array_creation_fwd (line 54) | def test_array_creation_fwd():

FILE: tests/conftest.py
  function random_seed (line 6) | def random_seed():

FILE: tests/numpy_utils.py
  function stat_check (line 5) | def stat_check(fun, test_complex=True, **kwargs):
  function unary_ufunc_check (line 23) | def unary_ufunc_check(fun, lims=[-2, 2], test_complex=True, **kwargs):
  function binary_ufunc_check (line 36) | def binary_ufunc_check(fun, lims_A=[-2, 2], lims_B=[-2, 2], test_complex...
  function binary_ufunc_check_no_same_args (line 54) | def binary_ufunc_check_no_same_args(fun, lims_A=[-2, 2], lims_B=[-2, 2],...
  function transform (line 81) | def transform(lims, x):

FILE: tests/profiling.py
  function tictoc (line 10) | def tictoc(text=""):
  function fan_out_fan_in (line 18) | def fan_out_fan_in():
  function convolution (line 30) | def convolution():
  function dot_equivalent (line 41) | def dot_equivalent():

FILE: tests/test_binary_ops.py
  function arg_pairs (line 12) | def arg_pairs():
  function test_mul (line 21) | def test_mul():
  function test_add (line 27) | def test_add():
  function test_sub (line 33) | def test_sub():
  function test_div (line 39) | def test_div():
  function test_mod (line 48) | def test_mod():
  function test_pow (line 58) | def test_pow():
  function test_arctan2 (line 66) | def test_arctan2():
  function test_hypot (line 71) | def test_hypot():
  function test_comparison_grads (line 76) | def test_comparison_grads():
  function test_comparison_values (line 94) | def test_comparison_values():

FILE: tests/test_builtins.py
  function test_isinstance (line 6) | def test_isinstance():

FILE: tests/test_complex.py
  function test_real_type (line 9) | def test_real_type():
  function test_real_if_close_type (line 16) | def test_real_if_close_type():
  function test_angle_real (line 23) | def test_angle_real():
  function test_angle_complex (line 30) | def test_angle_complex():
  function test_abs_real (line 37) | def test_abs_real():
  function test_abs_complex (line 44) | def test_abs_complex():

FILE: tests/test_core.py
  function grad (line 11) | def grad(fun, x):
  function nd (line 17) | def nd(f, x, eps=1e-4):
  function check_close (line 21) | def check_close(a, b, atol=1e-4, rtol=1e-4):
  function check_binary_func (line 25) | def check_binary_func(fun, independent=False):
  function test_add (line 37) | def test_add():
  function test_sub (line 41) | def test_sub():
  function test_div (line 45) | def test_div():
  function test_mul (line 49) | def test_mul():
  function test_pow (line 53) | def test_pow():
  function test_mod (line 57) | def test_mod():
  function test_eq (line 61) | def test_eq():
  function test_neq (line 65) | def test_neq():
  function test_leq (line 69) | def test_leq():
  function test_geq (line 73) | def test_geq():
  function test_lt (line 77) | def test_lt():
  function test_gt (line 81) | def test_gt():

FILE: tests/test_dict.py
  function test_getter (line 13) | def test_getter():
  function test_grads (line 29) | def test_grads():
  function test_iter (line 48) | def test_iter():
  function test_items_values_keys (line 70) | def test_items_values_keys():
  function test_get (line 96) | def test_get():
  function test_make_dict (line 105) | def test_make_dict():
  function test_isinstance (line 122) | def test_isinstance():

FILE: tests/test_direct.py
  function test_grad (line 13) | def test_grad():
  function test_deriv (line 20) | def test_deriv():
  function test_grad_complex_output (line 27) | def test_grad_complex_output():
  function test_holomorphic_grad (line 35) | def test_holomorphic_grad():

FILE: tests/test_fft.py
  function test_fft (line 15) | def test_fft():
  function test_fft_ortho (line 24) | def test_fft_ortho():
  function test_fft_axis (line 33) | def test_fft_axis():
  function match_complex (line 42) | def match_complex(fft_fun, mat):
  function check_fft_n (line 50) | def check_fft_n(fft_fun, D, n):
  function test_fft_n_smaller (line 59) | def test_fft_n_smaller():
  function test_fft_n_bigger (line 63) | def test_fft_n_bigger():
  function test_ifft_n_smaller (line 67) | def test_ifft_n_smaller():
  function test_ifft_n_bigger (line 71) | def test_ifft_n_bigger():
  function test_rfft_n_smaller (line 75) | def test_rfft_n_smaller():
  function test_rfft_n_bigger (line 79) | def test_rfft_n_bigger():
  function test_irfft_n_smaller (line 83) | def test_irfft_n_smaller():
  function test_irfft_n_bigger (line 87) | def test_irfft_n_bigger():
  function check_fft_s (line 91) | def check_fft_s(fft_fun, D):
  function test_fft2_s (line 102) | def test_fft2_s():
  function test_ifft2_s (line 106) | def test_ifft2_s():
  function test_fftn_s (line 110) | def test_fftn_s():
  function test_ifftn_s (line 114) | def test_ifftn_s():
  function test_rfft2_s (line 118) | def test_rfft2_s():
  function test_irfft2_s (line 122) | def test_irfft2_s():
  function test_rfftn_s (line 126) | def test_rfftn_s():
  function test_irfftn_s (line 130) | def test_irfftn_s():
  function test_ifft (line 147) | def test_ifft():
  function test_fft2 (line 156) | def test_fft2():
  function test_ifft2 (line 165) | def test_ifft2():
  function test_fftn (line 174) | def test_fftn():
  function test_ifftn (line 183) | def test_ifftn():
  function test_rfft (line 192) | def test_rfft():
  function test_rfft_ortho (line 201) | def test_rfft_ortho():
  function test_rfft_axes (line 210) | def test_rfft_axes():
  function test_irfft (line 219) | def test_irfft():
  function test_irfft_ortho (line 230) | def test_irfft_ortho():
  function test_rfft2 (line 241) | def test_rfft2():
  function test_irfft2 (line 250) | def test_irfft2():
  function test_rfftn (line 261) | def test_rfftn():
  function test_rfftn_odd_not_implemented (line 270) | def test_rfftn_odd_not_implemented():
  function test_rfftn_subset (line 280) | def test_rfftn_subset():
  function test_rfftn_axes (line 289) | def test_rfftn_axes():
  function test_irfftn (line 298) | def test_irfftn():
  function test_irfftn_subset (line 309) | def test_irfftn_subset():
  function test_fftshift (line 320) | def test_fftshift():
  function test_fftshift_even (line 329) | def test_fftshift_even():
  function test_fftshift_axes (line 338) | def test_fftshift_axes():
  function test_ifftshift (line 347) | def test_ifftshift():
  function test_ifftshift_even (line 356) | def test_ifftshift_even():
  function test_ifftshift_axes (line 365) | def test_ifftshift_axes():

FILE: tests/test_graphs.py
  function test_grad_fanout (line 13) | def test_grad_fanout():
  function test_grad_const (line 20) | def test_grad_const():
  function test_grad_identity (line 28) | def test_grad_identity():
  function test_hess_vector_prod (line 36) | def test_hess_vector_prod():
  function test_enclosing_scope_ref (line 55) | def test_enclosing_scope_ref():
  function test_enclosing_scope_ref_2 (line 63) | def test_enclosing_scope_ref_2():
  function test_mutating_outgrad (line 71) | def test_mutating_outgrad():
  function test_mutating_outgrad_from_indexing (line 83) | def test_mutating_outgrad_from_indexing():
  function test_complex_mutating_outgrad_from_indexing (line 95) | def test_complex_mutating_outgrad_from_indexing():
  function test_complex_separate_real_and_imaginary (line 109) | def test_complex_separate_real_and_imaginary():
  function test_third_derivative (line 121) | def test_third_derivative():
  function test_third_derivative_other_args (line 132) | def test_third_derivative_other_args():
  function test_third_derivative_other_args2 (line 143) | def test_third_derivative_other_args2():
  function test_singleton_array_output (line 154) | def test_singleton_array_output():
  function test_singleton_array_output_axis0 (line 160) | def test_singleton_array_output_axis0():
  function test_singleton_array_output_axis1 (line 166) | def test_singleton_array_output_axis1():
  function test_singleton_array_output_axis0_keepdims (line 172) | def test_singleton_array_output_axis0_keepdims():
  function test_singleton_array_output_axis1_keepdims (line 178) | def test_singleton_array_output_axis1_keepdims():
  function test_assignment_raises_error (line 184) | def test_assignment_raises_error():

FILE: tests/test_jacobian.py
  function test_jacobian_against_grad (line 9) | def test_jacobian_against_grad():
  function test_jacobian_scalar_to_vector (line 15) | def test_jacobian_scalar_to_vector():
  function test_jacobian_against_stacked_grads (line 21) | def test_jacobian_against_stacked_grads():
  function test_jacobian_higher_order (line 37) | def test_jacobian_higher_order():

FILE: tests/test_linalg.py
  function check_symmetric_matrix_grads (line 17) | def check_symmetric_matrix_grads(fun, **grad_check_kwargs):
  function rand_psd (line 32) | def rand_psd(D):
  function test_inv (line 37) | def test_inv():
  function test_pinv (line 47) | def test_pinv():
  function test_inv_3d (line 73) | def test_inv_3d():
  function test_solve_arg1 (line 84) | def test_solve_arg1():
  function test_solve_arg1_1d (line 95) | def test_solve_arg1_1d():
  function test_solve_arg2 (line 106) | def test_solve_arg2():
  function test_solve_arg1_3d (line 117) | def test_solve_arg1_3d():
  function test_solve_arg1_3d_3d (line 128) | def test_solve_arg1_3d_3d():
  function test_det (line 136) | def test_det():
  function test_det_3d (line 145) | def test_det_3d():
  function test_slogdet (line 152) | def test_slogdet():
  function test_slogdet_3d (line 163) | def test_slogdet_3d():
  function test_vector_2norm (line 169) | def test_vector_2norm():
  function test_vector_2norm_complex (line 178) | def test_vector_2norm_complex():
  function test_frobenius_norm (line 187) | def test_frobenius_norm():
  function test_frobenius_norm_complex (line 196) | def test_frobenius_norm_complex():
  function test_frobenius_norm_axis (line 205) | def test_frobenius_norm_axis():
  function test_frobenius_norm_axis_complex (line 214) | def test_frobenius_norm_axis_complex():
  function test_vector_norm_ord (line 225) | def test_vector_norm_ord(size, ord):
  function test_vector_norm_ord_complex (line 235) | def test_vector_norm_ord_complex(size, ord):
  function test_norm_axis (line 245) | def test_norm_axis(shape, axis):
  function test_norm_axis_complex (line 255) | def test_norm_axis_complex(shape, axis):
  function test_norm_nuclear (line 263) | def test_norm_nuclear():
  function test_norm_nuclear_complex (line 273) | def test_norm_nuclear_complex():
  function test_norm_nuclear_axis (line 282) | def test_norm_nuclear_axis():
  function test_norm_nuclear_axis_complex (line 292) | def test_norm_nuclear_axis_complex():
  function test_eigvalh_lower (line 301) | def test_eigvalh_lower():
  function test_eigvalh_upper (line 311) | def test_eigvalh_upper():
  function test_eigvalh_lower_broadcasting (line 324) | def test_eigvalh_lower_broadcasting():
  function test_eigvalh_upper_broadcasting (line 335) | def test_eigvalh_upper_broadcasting():
  function test_eigvalh_lower_complex (line 349) | def test_eigvalh_lower_complex():
  function test_eigvalh_upper_complex (line 359) | def test_eigvalh_upper_complex():
  function test_eig_real (line 370) | def test_eig_real():
  function test_eig_complex (line 380) | def test_eig_complex():
  function test_eig_batched (line 390) | def test_eig_batched():
  function test_cholesky (line 401) | def test_cholesky():
  function test_cholesky_broadcast (line 406) | def test_cholesky_broadcast():
  function test_cholesky_reparameterization_trick (line 412) | def test_cholesky_reparameterization_trick():
  function test_svd_wide_2d (line 421) | def test_svd_wide_2d():
  function test_svd_wide_2d_complex (line 432) | def test_svd_wide_2d_complex():
  function test_svd_wide_3d (line 443) | def test_svd_wide_3d():
  function test_svd_wide_3d_complex (line 455) | def test_svd_wide_3d_complex():
  function test_svd_square_2d (line 467) | def test_svd_square_2d():
  function test_svd_square_2d_complex (line 478) | def test_svd_square_2d_complex():
  function test_svd_square_3d (line 489) | def test_svd_square_3d():
  function test_svd_square_3d_complex (line 501) | def test_svd_square_3d_complex():
  function test_svd_tall_2d (line 513) | def test_svd_tall_2d():
  function test_svd_tall_2d_complex (line 524) | def test_svd_tall_2d_complex():
  function test_svd_tall_3d (line 535) | def test_svd_tall_3d():
  function test_svd_tall_3d_complex (line 547) | def test_svd_tall_3d_complex():
  function test_svd_only_s_2d (line 559) | def test_svd_only_s_2d():
  function test_svd_only_s_2d_complex (line 570) | def test_svd_only_s_2d_complex():
  function test_svd_only_s_3d (line 581) | def test_svd_only_s_3d():
  function test_svd_only_s_3d_complex (line 593) | def test_svd_only_s_3d_complex():

FILE: tests/test_list.py
  function test_getter (line 11) | def test_getter():
  function test_grads (line 27) | def test_grads():
  function test_slices (line 46) | def test_slices():
  function test_nested_list (line 61) | def test_nested_list():
  function test_make_list (line 70) | def test_make_list():
  function test_isinstance (line 77) | def test_isinstance():

FILE: tests/test_logic.py
  function test_assert (line 13) | def test_assert():
  function test_nograd (line 22) | def test_nograd():
  function test_no_vjp_def (line 30) | def test_no_vjp_def():
  function test_no_jvp_def (line 36) | def test_no_jvp_def():
  function test_falseyness (line 42) | def test_falseyness():
  function test_unimplemented_falseyness (line 48) | def test_unimplemented_falseyness():

FILE: tests/test_misc.py
  function test_const_graph (line 9) | def test_const_graph():
  function test_const_graph_args (line 27) | def test_const_graph_args():
  function test_flatten (line 54) | def test_flatten():
  function test_flatten_empty (line 68) | def test_flatten_empty():
  function test_flatten_dict (line 76) | def test_flatten_dict():
  function unflatten_tracing (line 85) | def unflatten_tracing():
  function test_flatten_nodes_in_containers (line 96) | def test_flatten_nodes_in_containers():
  function test_flatten_complex (line 105) | def test_flatten_complex():

FILE: tests/test_numpy.py
  function test_numpy_version (line 13) | def test_numpy_version():
  function test_dot (line 19) | def test_dot():
  function test_dot_with_floats (line 35) | def test_dot_with_floats():
  function test_outer (line 65) | def test_outer():
  function test_max (line 77) | def test_max():
  function test_max_axis (line 85) | def test_max_axis():
  function test_max_axis_keepdims (line 93) | def test_max_axis_keepdims():
  function test_min (line 101) | def test_min():
  function test_min_axis (line 109) | def test_min_axis():
  function test_min_axis_keepdims (line 117) | def test_min_axis_keepdims():
  function test_sum_1 (line 125) | def test_sum_1():
  function test_sum_2 (line 133) | def test_sum_2():
  function test_sum_3 (line 141) | def test_sum_3():
  function test_sum_with_axis_tuple (line 149) | def test_sum_with_axis_tuple():
  function test_flipud (line 157) | def test_flipud():
  function test_fliplr (line 165) | def test_fliplr():
  function test_rot90 (line 173) | def test_rot90():
  function test_cumsum_axis0 (line 181) | def test_cumsum_axis0():
  function test_cumsum_axis1 (line 189) | def test_cumsum_axis1():
  function test_cumsum_1d (line 197) | def test_cumsum_1d():
  function test_cumsum_no_axis (line 205) | def test_cumsum_no_axis():
  function test_non_numpy_sum (line 213) | def test_non_numpy_sum():
  function test_mean_1 (line 222) | def test_mean_1():
  function test_mean_2 (line 230) | def test_mean_2():
  function test_mean_3 (line 238) | def test_mean_3():
  function test_index_ints (line 246) | def test_index_ints():
  function test_index_slice (line 255) | def test_index_slice():
  function test_index_lists (line 264) | def test_index_lists():
  function test_index_mixed (line 273) | def test_index_mixed():
  function test_vector_slice (line 282) | def test_vector_slice():
  function test_index_slice_fanout (line 291) | def test_index_slice_fanout():
  function test_index_multiple_slices (line 302) | def test_index_multiple_slices():
  function test_reshape_method (line 313) | def test_reshape_method():
  function test_reshape_call (line 322) | def test_reshape_call():
  function test_reshape_method_nolist (line 331) | def test_reshape_method_nolist():
  function test_ravel_method (line 343) | def test_ravel_method():
  function test_ravel_call (line 352) | def test_ravel_call():
  function test_flatten_method (line 361) | def test_flatten_method():
  function test_simple_append_list (line 370) | def test_simple_append_list():
  function test_simple_append_arr (line 376) | def test_simple_append_arr():
  function test_simple_append_list_2D (line 382) | def test_simple_append_list_2D():
  function test_simple_concatenate (line 388) | def test_simple_concatenate():
  function test_concatenate_axis_0 (line 398) | def test_concatenate_axis_0():
  function test_concatenate_axis_1 (line 408) | def test_concatenate_axis_1():
  function test_concatenate_axis_1_unnamed (line 418) | def test_concatenate_axis_1_unnamed():
  function test_trace (line 429) | def test_trace():
  function test_trace2 (line 438) | def test_trace2():
  function test_trace_extradims (line 447) | def test_trace_extradims():
  function test_diag (line 464) | def test_diag():
  function test_transpose (line 472) | def test_transpose():
  function test_roll (line 480) | def test_roll():
  function test_roll_no_axis (line 488) | def test_roll_no_axis():
  function test_triu (line 496) | def test_triu():
  function test_tril (line 504) | def test_tril():
  function test_clip (line 512) | def test_clip():
  function test_prod_1 (line 520) | def test_prod_1():
  function test_prod_2 (line 528) | def test_prod_2():
  function test_prod_3 (line 536) | def test_prod_3():
  function test_prod_4 (line 544) | def test_prod_4():
  function test_1d_array (line 552) | def test_1d_array():
  function test_2d_array (line 559) | def test_2d_array():
  function test_1d_array_fanout (line 566) | def test_1d_array_fanout():
  function test_2d_array_fanout (line 574) | def test_2d_array_fanout():
  function test_array_from_scalar (line 582) | def test_array_from_scalar():
  function test_array_from_arrays (line 589) | def test_array_from_arrays():
  function test_array_from_arrays_2 (line 597) | def test_array_from_arrays_2():
  function test_len (line 605) | def test_len():
  function test_r_basic (line 614) | def test_r_basic():
  function test_r_double (line 626) | def test_r_double():
  function test_no_relation (line 638) | def test_no_relation():
  function test_r_no_relation (line 649) | def test_r_no_relation():
  function test_r_node_and_const (line 661) | def test_r_node_and_const():
  function test_r_mixed (line 673) | def test_r_mixed():
  function test_r_slicing (line 685) | def test_r_slicing():
  function test_c_ (line 697) | def test_c_():
  function test_c_mixed (line 709) | def test_c_mixed():
  function test_var_ddof (line 721) | def test_var_ddof():
  function test_std_ddof (line 729) | def test_std_ddof():
  function test_where (line 737) | def test_where():
  function test_squeeze_func (line 748) | def test_squeeze_func():
  function test_squeeze_method (line 757) | def test_squeeze_method():
  function test_repeat (line 766) | def test_repeat():
  function test_repeat_axis1_rep1 (line 775) | def test_repeat_axis1_rep1():
  function test_repeat_axis0 (line 784) | def test_repeat_axis0():
  function test_repeat_1d_axis0 (line 793) | def test_repeat_1d_axis0():
  function test_repeat_axis0_rep1 (line 802) | def test_repeat_axis0_rep1():
  function test_expand_dims (line 811) | def test_expand_dims():
  function test_tensordot_kwargs_by_position (line 820) | def test_tensordot_kwargs_by_position():
  function test_multi_index (line 827) | def test_multi_index():
  function test_multi_index2 (line 833) | def test_multi_index2():
  function test_index_dot_slices (line 839) | def test_index_dot_slices():
  function test_cast_to_int (line 866) | def test_cast_to_int():
  function test_make_diagonal (line 884) | def test_make_diagonal():
  function test_diagonal (line 899) | def test_diagonal():
  function test_nan_to_num (line 912) | def test_nan_to_num():
  function test_max_equal_values (line 928) | def test_max_equal_values():
  function test_max_equal_values_2d (line 935) | def test_max_equal_values_2d():
  function test_min_3_way_equality (line 943) | def test_min_3_way_equality():
  function test_maximum_equal_values (line 951) | def test_maximum_equal_values():
  function test_maximum_equal_values_2d (line 958) | def test_maximum_equal_values_2d():
  function test_linspace (line 967) | def test_linspace():
  function test_astype (line 978) | def test_astype():
  function test_gradient (line 987) | def test_gradient():

FILE: tests/test_scalar_ops.py
  function test_abs (line 9) | def test_abs():
  function test_absolute (line 16) | def test_absolute():
  function test_sin (line 23) | def test_sin():
  function test_sign (line 28) | def test_sign():
  function test_exp (line 34) | def test_exp():
  function test_log (line 39) | def test_log():
  function test_log2 (line 44) | def test_log2():
  function test_log10 (line 49) | def test_log10():
  function test_log1p (line 54) | def test_log1p():
  function test_expm1 (line 59) | def test_expm1():
  function test_exp2 (line 64) | def test_exp2():
  function test_neg (line 69) | def test_neg():
  function test_cos (line 74) | def test_cos():
  function test_tan (line 79) | def test_tan():
  function test_cosh (line 84) | def test_cosh():
  function test_sinh (line 89) | def test_sinh():
  function test_tanh (line 94) | def test_tanh():
  function test_arccos (line 99) | def test_arccos():
  function test_arcsin (line 104) | def test_arcsin():
  function test_arctan (line 109) | def test_arctan():
  function test_arccosh (line 114) | def test_arccosh():
  function test_arcsinh (line 119) | def test_arcsinh():
  function test_arctanh (line 124) | def test_arctanh():
  function test_sqrt (line 129) | def test_sqrt():
  function test_power_arg0 (line 134) | def test_power_arg0():
  function test_power_arg1 (line 146) | def test_power_arg1():
  function test_power_arg1_zero (line 152) | def test_power_arg1_zero():
  function test_mod_arg0 (line 157) | def test_mod_arg0():
  function test_mod_arg1 (line 162) | def test_mod_arg1():
  function test_divide_arg0 (line 167) | def test_divide_arg0():
  function test_divide_arg1 (line 172) | def test_divide_arg1():
  function test_multiply_arg0 (line 177) | def test_multiply_arg0():
  function test_multiply_arg1 (line 182) | def test_multiply_arg1():
  function test_true_divide_arg0 (line 187) | def test_true_divide_arg0():
  function test_true_divide_arg1 (line 192) | def test_true_divide_arg1():
  function test_reciprocal (line 197) | def test_reciprocal():
  function test_negative (line 202) | def test_negative():
  function test_rad2deg (line 207) | def test_rad2deg():
  function test_deg2rad (line 212) | def test_deg2rad():
  function test_radians (line 217) | def test_radians():
  function test_degrees (line 222) | def test_degrees():
  function test_sinc (line 227) | def test_sinc():

FILE: tests/test_scipy.py
  function symmetrize_matrix_arg (line 35) | def symmetrize_matrix_arg(fun, argnum):
  function test_chi2_pdf (line 50) | def test_chi2_pdf():
  function test_chi2_cdf (line 53) | def test_chi2_cdf():
  function test_chi2_logpdf (line 56) | def test_chi2_logpdf():
  function test_beta_cdf (line 59) | def test_beta_cdf():
  function test_beta_pdf (line 62) | def test_beta_pdf():
  function test_beta_logpdf (line 65) | def test_beta_logpdf():
  function test_gamma_cdf (line 68) | def test_gamma_cdf():
  function test_gamma_pdf (line 71) | def test_gamma_pdf():
  function test_gamma_logpdf (line 74) | def test_gamma_logpdf():
  function test_norm_pdf (line 77) | def test_norm_pdf():
  function test_norm_cdf (line 80) | def test_norm_cdf():
  function test_norm_sf (line 83) | def test_norm_sf():
  function test_norm_logpdf (line 86) | def test_norm_logpdf():
  function test_norm_logcdf (line 89) | def test_norm_logcdf():
  function test_norm_logsf (line 92) | def test_norm_logsf():
  function test_norm_pdf_broadcast (line 95) | def test_norm_pdf_broadcast():
  function test_norm_cdf_broadcast (line 98) | def test_norm_cdf_broadcast():
  function test_norm_sf_broadcast (line 101) | def test_norm_sf_broadcast():
  function test_norm_logpdf_broadcast (line 104) | def test_norm_logpdf_broadcast():
  function test_norm_logcdf_broadcast (line 107) | def test_norm_logcdf_broadcast():
  function test_norm_logsf_broadcast (line 110) | def test_norm_logsf_broadcast():
  function test_poisson_cdf (line 113) | def test_poisson_cdf():
  function test_poisson_logpmf (line 116) | def test_poisson_logpmf():
  function test_poisson_pmf (line 119) | def test_poisson_pmf():
  function test_poisson_cdf_broadcast (line 122) | def test_poisson_cdf_broadcast():
  function test_poisson_logpmf_broadcast (line 125) | def test_poisson_logpmf_broadcast():
  function test_poisson_pmf_broadcast (line 128) | def test_poisson_pmf_broadcast():
  function test_t_pdf (line 131) | def test_t_pdf():
  function test_t_cdf (line 134) | def test_t_cdf():
  function test_t_logpdf (line 137) | def test_t_logpdf():
  function test_t_logcdf (line 140) | def test_t_logcdf():
  function test_t_pdf_broadcast (line 143) | def test_t_pdf_broadcast():
  function test_t_cdf_broadcast (line 148) | def test_t_cdf_broadcast():
  function test_t_logpdf_broadcast (line 151) | def test_t_logpdf_broadcast():
  function test_t_logcdf_broadcast (line 156) | def test_t_logcdf_broadcast():
  function make_psd (line 159) | def make_psd(mat):
  function test_mvn_pdf (line 162) | def test_mvn_pdf():
  function test_mvn_logpdf (line 167) | def test_mvn_logpdf():
  function test_mvn_entropy (line 172) | def test_mvn_entropy():
  function test_mvn_sing_cov (line 175) | def test_mvn_sing_cov():
  function test_mvn_pdf_broadcast (line 197) | def test_mvn_pdf_broadcast():
  function test_mvn_logpdf_broadcast (line 200) | def test_mvn_logpdf_broadcast():
  function normalize (line 207) | def normalize(x):
  function normalized_dirichlet_pdf (line 210) | def normalized_dirichlet_pdf(x, alpha):
  function normalized_dirichlet_logpdf (line 213) | def normalized_dirichlet_logpdf(x, alpha):
  function test_dirichlet_pdf_x (line 216) | def test_dirichlet_pdf_x():
  function test_dirichlet_pdf_alpha (line 219) | def test_dirichlet_pdf_alpha():
  function test_dirichlet_logpdf_x (line 222) | def test_dirichlet_logpdf_x():
  function test_dirichlet_logpdf_alpha (line 225) | def test_dirichlet_logpdf_alpha():
  function test_logsumexp1 (line 229) | def test_logsumexp1():
  function test_logsumexp2 (line 234) | def test_logsumexp2():
  function test_logsumexp3 (line 239) | def test_logsumexp3():
  function test_logsumexp4 (line 244) | def test_logsumexp4():
  function test_logsumexp5 (line 254) | def test_logsumexp5():
  function test_logsumexp6 (line 259) | def test_logsumexp6():
  function test_convolve_generalization (line 269) | def test_convolve_generalization():
  function test_convolve (line 302) | def test_convolve():
  function test_convolve_2d (line 307) | def test_convolve_2d():
  function test_convolve_ignore (line 312) | def test_convolve_ignore():
  function test_convolve_ignore_dot (line 320) | def test_convolve_ignore_dot():
  function test_beta (line 330) | def test_beta():
  function test_betainc (line 333) | def test_betainc():
  function test_betaln (line 336) | def test_betaln():
  function test_gammainc (line 339) | def test_gammainc():
  function test_gammaincc (line 342) | def test_gammaincc():
  function test_polygamma (line 345) | def test_polygamma():
  function test_jn (line 348) | def test_jn():
  function test_yn (line 351) | def test_yn():
  function test_psi (line 354) | def test_psi():
  function test_digamma (line 357) | def test_digamma():
  function test_gamma (line 360) | def test_gamma():
  function test_gammaln (line 363) | def test_gammaln():
  function test_gammasgn (line 366) | def test_gammasgn():
  function test_rgamma (line 369) | def test_rgamma():
  function test_multigammaln (line 372) | def test_multigammaln():
  function test_j0 (line 375) | def test_j0():
  function test_j1 (line 378) | def test_j1():
  function test_y0 (line 381) | def test_y0():
  function test_y1 (line 384) | def test_y1():
  function test_i0 (line 387) | def test_i0():
  function test_i1 (line 390) | def test_i1():
  function test_iv (line 393) | def test_iv():
  function test_ive (line 396) | def test_ive():
  function test_erf (line 399) | def test_erf():
  function test_erfc (line 402) | def test_erfc():
  function test_erfinv (line 405) | def test_erfinv():
  function test_erfcinv (line 408) | def test_erfcinv():
  function test_logit (line 411) | def test_logit():
  function test_expit (line 414) | def test_expit():
  function func (line 418) | def func(y, t, arg1, arg2):
  function test_odeint (line 421) | def test_odeint():
  function test_sqrtm (line 425) | def test_sqrtm():
  function test_sqrtm (line 428) | def test_sqrtm():
  function test_solve_sylvester (line 431) | def test_solve_sylvester():
  function test_solve_banded (line 436) | def test_solve_banded():

FILE: tests/test_systematic.py
  function test_max (line 14) | def test_max():
  function test_max (line 20) | def test_max():
  function test_mean (line 24) | def test_mean():
  function test_min (line 28) | def test_min():
  function test_sum (line 32) | def test_sum():
  function test_prod (line 36) | def test_prod():
  function test_var (line 40) | def test_var():
  function test_std (line 44) | def test_std():
  function test_sin (line 51) | def test_sin():
  function test_abs (line 55) | def test_abs():
  function test_absolute (line 59) | def test_absolute():
  function test_arccosh (line 63) | def test_arccosh():
  function test_arcsinh (line 67) | def test_arcsinh():
  function test_arctanh (line 71) | def test_arctanh():
  function test_ceil (line 75) | def test_ceil():
  function test_cos (line 79) | def test_cos():
  function test_cosh (line 83) | def test_cosh():
  function test_deg2rad (line 87) | def test_deg2rad():
  function test_degrees (line 91) | def test_degrees():
  function test_exp (line 95) | def test_exp():
  function test_exp2 (line 99) | def test_exp2():
  function test_expm1 (line 103) | def test_expm1():
  function test_fabs (line 107) | def test_fabs():
  function test_floor (line 111) | def test_floor():
  function test_log (line 115) | def test_log():
  function test_log10 (line 119) | def test_log10():
  function test_log1p (line 123) | def test_log1p():
  function test_log2 (line 127) | def test_log2():
  function test_rad2deg (line 131) | def test_rad2deg():
  function test_radians (line 135) | def test_radians():
  function test_sign (line 139) | def test_sign():
  function test_sin (line 143) | def test_sin():
  function test_sinh (line 147) | def test_sinh():
  function test_sqrt (line 151) | def test_sqrt():
  function test_square (line 155) | def test_square():
  function test_tan (line 159) | def test_tan():
  function test_tanh (line 163) | def test_tanh():
  function test_real (line 167) | def test_real():
  function test_real_ic (line 171) | def test_real_ic():
  function test_imag (line 175) | def test_imag():
  function test_conj (line 179) | def test_conj():
  function test_conjugate (line 183) | def test_conjugate():
  function test_angle (line 187) | def test_angle():
  function test_add (line 194) | def test_add():
  function test_logaddexp (line 198) | def test_logaddexp():
  function test_logaddexp2 (line 202) | def test_logaddexp2():
  function test_remainder (line 206) | def test_remainder():
  function test_true_divide (line 210) | def test_true_divide():
  function test_mod (line 214) | def test_mod():
  function test_true_divide_neg (line 218) | def test_true_divide_neg():
  function test_mod_neg (line 222) | def test_mod_neg():
  function test_op_mul (line 226) | def test_op_mul():
  function test_op_add (line 230) | def test_op_add():
  function test_op_sub (line 234) | def test_op_sub():
  function test_op_mod (line 238) | def test_op_mod():
  function test_op_mod_neg (line 242) | def test_op_mod_neg():
  function test_transpose (line 252) | def test_transpose():
  function test_moveaxis (line 258) | def test_moveaxis():
  function test_repeat (line 262) | def test_repeat():
  function test_diff (line 266) | def test_diff():
  function test_gradient (line 272) | def test_gradient():
  function test_tile (line 277) | def test_tile():
  function test_kron (line 283) | def test_kron():
  function test_inner (line 290) | def test_inner():
  function test_dot (line 294) | def test_dot():
  function test_outer (line 300) | def test_outer():
  function test_matmul (line 304) | def test_matmul():
  function test_matmul_broadcast (line 310) | def test_matmul_broadcast():
  function test_tensordot_1 (line 314) | def test_tensordot_1():
  function test_tensordot_2 (line 320) | def test_tensordot_2():
  function test_tensordot_3 (line 326) | def test_tensordot_3():
  function test_tensordot_4 (line 332) | def test_tensordot_4():
  function test_tensordot_5 (line 336) | def test_tensordot_5():
  function test_tensordot_6 (line 340) | def test_tensordot_6():
  function test_tensordot_7 (line 344) | def test_tensordot_7():
  function test_tensordot_8 (line 348) | def test_tensordot_8():
  function test_maximum (line 353) | def test_maximum():
  function test_fmax (line 357) | def test_fmax():
  function test_minimum (line 361) | def test_minimum():
  function test_fmin (line 365) | def test_fmin():
  function test_sort (line 369) | def test_sort():
  function test_msort (line 375) | def test_msort():
  function test_partition (line 379) | def test_partition():
  function test_atleast_1d (line 383) | def test_atleast_1d():
  function test_atleast_2d (line 387) | def test_atleast_2d():
  function test_atleast_3d (line 391) | def test_atleast_3d():
  function test_einsum_transpose (line 395) | def test_einsum_transpose():
  function test_einsum_matmult (line 399) | def test_einsum_matmult():
  function test_einsum_matmult_broadcast (line 403) | def test_einsum_matmult_broadcast():
  function test_einsum_matmult_broadcast_leadzero (line 407) | def test_einsum_matmult_broadcast_leadzero():
  function test_einsum_covsum (line 411) | def test_einsum_covsum():
  function test_einsum_ellipses (line 415) | def test_einsum_ellipses():
  function test_einsum_ellipses_tail (line 421) | def test_einsum_ellipses_tail():
  function test_einsum_ellipses_center (line 425) | def test_einsum_ellipses_center():
  function test_einsum_three_args (line 429) | def test_einsum_three_args():
  function test_einsum2_transpose (line 433) | def test_einsum2_transpose():
  function test_einsum2_matmult (line 437) | def test_einsum2_matmult():
  function test_einsum2_matmult_broadcast (line 441) | def test_einsum2_matmult_broadcast():
  function test_einsum2_covsum (line 451) | def test_einsum2_covsum():
  function test_einsum2_three_args (line 455) | def test_einsum2_three_args():
  function test_einsum_naked_sum (line 461) | def test_einsum_naked_sum():
  function test_einsum_naked_sum2 (line 465) | def test_einsum_naked_sum2():
  function test_einsum_naked_sum_ellipsis (line 469) | def test_einsum_naked_sum_ellipsis():
  function test_einsum_no_output_indices (line 473) | def test_einsum_no_output_indices():
  function test_trace (line 477) | def test_trace():
  function test_diag (line 481) | def test_diag():
  function test_diag_flat (line 485) | def test_diag_flat():
  function test_tril (line 489) | def test_tril():
  function test_triu (line 493) | def test_triu():
  function test_tril_3d (line 497) | def test_tril_3d():
  function test_triu_3d (line 501) | def test_triu_3d():
  function test_swapaxes (line 505) | def test_swapaxes():
  function test_rollaxis (line 509) | def test_rollaxis():
  function test_cross (line 513) | def test_cross():
  function test_vsplit_2d (line 519) | def test_vsplit_2d():
  function test_vsplit_3d (line 523) | def test_vsplit_3d():
  function test_hsplit_2d (line 527) | def test_hsplit_2d():
  function test_hsplit_3d (line 531) | def test_hsplit_3d():
  function test_dsplit_3d (line 535) | def test_dsplit_3d():
  function test_split_1d (line 539) | def test_split_1d():
  function test_split_2d (line 543) | def test_split_2d():
  function test_split_3d (line 547) | def test_split_3d():
  function test_array_split_1d (line 551) | def test_array_split_1d():
  function test_array_split_2d (line 555) | def test_array_split_2d():
  function test_array_split_3d (line 559) | def test_array_split_3d():
  function test_concatenate_1ist (line 563) | def test_concatenate_1ist():
  function test_concatenate_tuple (line 567) | def test_concatenate_tuple():
  function test_concatenate_2d (line 571) | def test_concatenate_2d():
  function test_concatenate_3d (line 575) | def test_concatenate_3d():
  function test_vstack_1d (line 579) | def test_vstack_1d():
  function test_vstack_2d (line 583) | def test_vstack_2d():
  function test_vstack_3d (line 587) | def test_vstack_3d():
  function test_hstack_1d (line 591) | def test_hstack_1d():
  function test_hstack_2d (line 595) | def test_hstack_2d():
  function test_hstack_3d (line 599) | def test_hstack_3d():
  function test_stack_1d (line 603) | def test_stack_1d():
  function test_row_stack_1d (line 607) | def test_row_stack_1d():
  function test_row_stack_2d (line 611) | def test_row_stack_2d():
  function test_column_stack_1d (line 615) | def test_column_stack_1d():
  function test_column_stack_2d (line 619) | def test_column_stack_2d():
  function test_select (line 623) | def test_select():
  function test_pad (line 631) | def test_pad():

FILE: tests/test_tests.py
  function test_check_vjp_1st_order_fail (line 8) | def test_check_vjp_1st_order_fail():
  function test_check_vjp_2nd_order_fail (line 19) | def test_check_vjp_2nd_order_fail():

FILE: tests/test_truediv.py
  function test_div (line 9) | def test_div():

FILE: tests/test_tuple.py
  function test_getter (line 11) | def test_getter():
  function test_grads (line 27) | def test_grads():
  function test_nested_higher_order (line 46) | def test_nested_higher_order():
  function test_isinstance (line 58) | def test_isinstance():

FILE: tests/test_vspaces.py
  function check_vspace (line 10) | def check_vspace(value):
  function test_array_vspace (line 136) | def test_array_vspace():
  function test_array_vspace_0_dim (line 140) | def test_array_vspace_0_dim():
  function test_array_vspace_complex (line 144) | def test_array_vspace_complex():
  function test_list_vspace (line 148) | def test_list_vspace():
  function test_tuple_vspace (line 152) | def test_tuple_vspace():
  function test_dict_vspace (line 156) | def test_dict_vspace():
  function test_mixed_vspace (line 160) | def test_mixed_vspace():

FILE: tests/test_wrappers.py
  function test_return_both (line 28) | def test_return_both():
  function test_value_and_grad (line 39) | def test_value_and_grad():
  function test_hessian (line 54) | def test_hessian():
  function test_multigrad (line 67) | def test_multigrad():
  function test_value_and_multigrad (line 88) | def test_value_and_multigrad():
  function test_multigrad_onearg (line 108) | def test_multigrad_onearg():
  function test_elementwise_grad (line 115) | def test_elementwise_grad():
  function test_elementwise_grad_multiple_args (line 126) | def test_elementwise_grad_multiple_args():
  function test_hessian_tensor_product (line 139) | def test_hessian_tensor_product():
  function test_hvp (line 147) | def test_hvp():
  function test_hessian_matrix_product (line 156) | def test_hessian_matrix_product():
  function test_hessian_tensor_product_3d (line 164) | def test_hessian_tensor_product_3d():
  function test_tensor_jacobian_product (line 172) | def test_tensor_jacobian_product():
  function test_matrix_jacobian_product (line 181) | def test_matrix_jacobian_product():
  function test_tensor_jacobian_product (line 189) | def test_tensor_jacobian_product():
  function test_deprecated_defgrad_wrapper (line 197) | def test_deprecated_defgrad_wrapper():
  function test_deprecated_defvjp_wrapper (line 216) | def test_deprecated_defvjp_wrapper():
  function test_deprecated_defvjp_is_zero_wrapper (line 235) | def test_deprecated_defvjp_is_zero_wrapper():
  function test_deprecated_quick_grad_check_wrapper (line 254) | def test_deprecated_quick_grad_check_wrapper():
  function test_partial (line 261) | def test_partial():
  function test_dtypes (line 269) | def test_dtypes():
  function test_checkpoint_correctness (line 287) | def test_checkpoint_correctness():
  function checkpoint_memory (line 303) | def checkpoint_memory():
  function test_make_jvp (line 332) | def test_make_jvp():
  function _make_explicit_ggnvp (line 344) | def _make_explicit_ggnvp(f, g=lambda x: 1.0 / 2 * np.dot(x, x)):
  function test_make_ggnvp (line 357) | def test_make_ggnvp():
  function test_make_ggnvp_nondefault_g (line 369) | def test_make_ggnvp_nondefault_g():
  function test_grad_and_aux (line 383) | def test_grad_and_aux():
  function test_wrapped_name_and_docs (line 408) | def test_wrapped_name_and_docs():