`core`¶

label='fast'

>>> np.lib.test() #doctest: +SKIP

>>> result = np.lib.test() #doctest: +SKIP
Running unit tests for numpy.lib
...
Ran 976 tests in 3.933s

>>> result.errors #doctest: +SKIP
[]
>>> result.knownfail #doctest: +SKIP
[]

>>> cart_distance([0,0,0], [0,0,3])
3.0

>>> import math
>>> import numpy as np
>>> import dipy.core.geometry as gm
>>> scale = np.random.random(3) - 0.5
>>> shear = np.random.random(3) - 0.5
>>> angles = (np.random.random(3) - 0.5) * (2*math.pi)
>>> trans = np.random.random(3) - 0.5
>>> persp = np.random.random(4) - 0.5
>>> M0 = gm.compose_matrix(scale, shear, angles, trans, persp)

>>> import numpy as np
>>> T0=np.diag([2,1,1,1])
>>> scale, shear, angles, trans, persp = decompose_matrix(T0)

>>> import numpy
>>> R = euler_matrix(1, 2, 3, 'syxz')
>>> numpy.allclose(numpy.sum(R[0]), -1.34786452)
True
>>> R = euler_matrix(1, 2, 3, (0, 1, 0, 1))
>>> numpy.allclose(numpy.sum(R[0]), -0.383436184)
True
>>> ai, aj, ak = (4.0*math.pi) * (numpy.random.random(3) - 0.5)
>>> for axes in _AXES2TUPLE.keys():
...    _ = euler_matrix(ai, aj, ak, axes)
>>> for axes in _TUPLE2AXES.keys():
...    _ = euler_matrix(ai, aj, ak, axes)

>>> B = np.diag([1, 1, -1])
>>> nearest_pos_semi_def(B)
array([[ 0.75,  0.  ,  0.  ],
       [ 0.  ,  0.75,  0.  ],
       [ 0.  ,  0.  ,  0.  ]])

>>> vec = [1, 2, 3]
>>> l2n = np.sqrt(np.dot(vec, vec))
>>> nvec = normalized_vector(vec)
>>> np.allclose(np.array(vec) / l2n, nvec)
True
>>> vec = np.array([[1, 2, 3]])
>>> vec.shape == (1, 3)
True
>>> normalized_vector(vec).shape == (1, 3)
True

       0  -nz  ny
Sn =   nz   0 -nx
      -ny  nx   0

>>> import numpy as np
>>> from dipy.core.geometry import rodrigues_axis_rotation
>>> v=np.array([0,0,1])
>>> u=np.array([1,0,0])
>>> R=rodrigues_axis_rotation(v,40)
>>> ur=np.dot(R,u)
>>> np.round(np.rad2deg(np.arccos(np.dot(ur,u))))
40.0

>>> print('%.4f' % sphere_distance([0,1],[1,0]))
1.5708
>>> print('%.4f' % sphere_distance([0,3],[3,0]))
4.7124

>>> import numpy as np
>>> from dipy.core.geometry import vec2vec_rotmat
>>> u=np.array([1,0,0])
>>> v=np.array([0,1,0])
>>> R=vec2vec_rotmat(u,v)
>>> np.dot(R,u)
array([ 0.,  1.,  0.])
>>> np.dot(R.T,v)
array([ 1.,  0.,  0.])

v_cos = np.inner(v1, v2) / (np.sqrt(np.sum(v1**2)) *
                            np.sqrt(np.sum(v2**2)))

>>> import numpy as np
>>> vec = [[8, 15, 0], [0, 36, 77]]
>>> vector_norm(vec)
array([ 17.,  85.])
>>> vector_norm(vec, keepdims=True)
array([[ 17.],
       [ 85.]])
>>> vector_norm(vec, axis=0)
array([  8.,  39.,  77.])

HemiSphere(x, y, z)
HemiSphere(xyz=xyz)
HemiSphere(theta=theta, phi=phi)

>>> class MagicProp(object):
...     @auto_attr
...     def a(self):
...         return 99
...
>>> x = MagicProp()
>>> 'a' in x.__dict__
False
>>> x.a
99
>>> 'a' in x.__dict__
True

>>> from dipy.core.gradients import gradient_table
>>> bvals = 1500 * np.ones(7)
>>> bvals[0] = 0
>>> sq2 = np.sqrt(2) / 2
>>> bvecs = np.array([[0, 0, 0],
...                   [1, 0, 0],
...                   [0, 1, 0],
...                   [0, 0, 1],
...                   [sq2, sq2, 0],
...                   [sq2, 0, sq2],
...                   [0, sq2, sq2]])
>>> gt = gradient_table(bvals, bvecs)
>>> gt.bvecs.shape == bvecs.shape
True
>>> gt = gradient_table(bvals, bvecs.T)
>>> gt.bvecs.shape == bvecs.T.shape
False

>>> from dipy.core.gradients import (
...    gradient_table_from_gradient_strength_bvecs)
>>> gradient_strength = .03e-3 * np.ones(7)  # clinical strength at 30 mT/m
>>> big_delta = .03  # pulse separation of 30ms
>>> small_delta = 0.01  # pulse duration of 10ms
>>> gradient_strength[0] = 0
>>> sq2 = np.sqrt(2) / 2
>>> bvecs = np.array([[0, 0, 0],
...                   [1, 0, 0],
...                   [0, 1, 0],
...                   [0, 0, 1],
...                   [sq2, sq2, 0],
...                   [sq2, 0, sq2],
...                   [0, sq2, sq2]])
>>> gt = gradient_table_from_gradient_strength_bvecs(
...     gradient_strength, bvecs, big_delta, small_delta)

>>> from dipy.core.gradients import gradient_table_from_qvals_bvecs
>>> qvals = 30. * np.ones(7)
>>> big_delta = .03  # pulse separation of 30ms
>>> small_delta = 0.01  # pulse duration of 10ms
>>> qvals[0] = 0
>>> sq2 = np.sqrt(2) / 2
>>> bvecs = np.array([[0, 0, 0],
...                   [1, 0, 0],
...                   [0, 1, 0],
...                   [0, 0, 1],
...                   [sq2, sq2, 0],
...                   [sq2, 0, sq2],
...                   [0, sq2, sq2]])
>>> gt = gradient_table_from_qvals_bvecs(qvals, bvecs,
...                                      big_delta, small_delta)

>>> from scipy import linalg
>>> a = np.array([[1., 2.], [3., 4.]])
>>> linalg.inv(a)
array([[-2. ,  1. ],
       [ 1.5, -0.5]])
>>> np.dot(a, linalg.inv(a))
array([[ 1.,  0.],
       [ 0.,  1.]])

>>> from scipy.linalg import polar
>>> a = np.array([[1, -1], [2, 4]])
>>> u, p = polar(a)
>>> u
array([[ 0.85749293, -0.51449576],
       [ 0.51449576,  0.85749293]])
>>> p
array([[ 1.88648444,  1.2004901 ],
       [ 1.2004901 ,  3.94446746]])

>>> b = np.array([[0.5, 1, 2], [1.5, 3, 4]])
>>> u, p = polar(b)
>>> u
array([[-0.21196618, -0.42393237,  0.88054056],
       [ 0.39378971,  0.78757942,  0.4739708 ]])
>>> p
array([[ 0.48470147,  0.96940295,  1.15122648],
       [ 0.96940295,  1.9388059 ,  2.30245295],
       [ 1.15122648,  2.30245295,  3.65696431]])
>>> u.dot(p)   # Verify the decomposition.
array([[ 0.5,  1. ,  2. ],
       [ 1.5,  3. ,  4. ]])
>>> u.dot(u.T)   # The rows of u are orthonormal.
array([[  1.00000000e+00,  -2.07353665e-17],
       [ -2.07353665e-17,   1.00000000e+00]])

>>> c = b.T
>>> u, p = polar(c)
>>> u
array([[-0.21196618,  0.39378971],
       [-0.42393237,  0.78757942],
       [ 0.88054056,  0.4739708 ]])
>>> p
array([[ 1.23116567,  1.93241587],
       [ 1.93241587,  4.84930602]])
>>> u.dot(p)   # Verify the decomposition.
array([[ 0.5,  1.5],
       [ 1. ,  3. ],
       [ 2. ,  4. ]])
>>> u.T.dot(u)  # The columns of u are orthonormal.
array([[  1.00000000e+00,  -1.26363763e-16],
       [ -1.26363763e-16,   1.00000000e+00]])

>>> import numpy as np
>>> vec = [[8, 15, 0], [0, 36, 77]]
>>> vector_norm(vec)
array([ 17.,  85.])
>>> vector_norm(vec, keepdims=True)
array([[ 17.],
       [ 85.]])
>>> vector_norm(vec, axis=0)
array([  8.,  39.,  77.])

>>> from dipy.core.graph import Graph
>>> g=Graph()
>>> g.add_node('a',5)
>>> g.add_node('b',6)
>>> g.add_node('c',10)
>>> g.add_node('d',11)
>>> g.add_edge('a','b')
>>> g.add_edge('b','c')
>>> g.add_edge('c','d')
>>> g.add_edge('b','d')
>>> g.up_short('d')
['d', 'b', 'a']

>>> from dipy.core.ndindex import ndindex
>>> shape = (3, 2, 1)
>>> for index in ndindex(shape):
...     print(index)
(0, 0, 0)
(0, 1, 0)
(1, 0, 0)
(1, 1, 0)
(2, 0, 0)
(2, 1, 0)

>>> class A(ResetMixin):
...     def __init__(self,x=1.0):
...         self.x = x
...
...     @auto_attr
...     def y(self):
...         print('*** y computation executed ***')
...         return self.x / 2.0
...

>>> a = A(10)

>>> class MagicProp(object):
...     @auto_attr
...     def a(self):
...         return 99
...
>>> x = MagicProp()
>>> 'a' in x.__dict__
False
>>> x.a
99
>>> 'a' in x.__dict__
True

>>> from scipy.optimize import minimize, rosen, rosen_der

>>> x0 = [1.3, 0.7, 0.8, 1.9, 1.2]
>>> res = minimize(rosen, x0, method='Nelder-Mead', tol=1e-6)
>>> res.x
array([ 1.,  1.,  1.,  1.,  1.])

>>> res = minimize(rosen, x0, method='BFGS', jac=rosen_der,
...                options={'gtol': 1e-6, 'disp': True})
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 26
         Function evaluations: 31
         Gradient evaluations: 31
>>> res.x
array([ 1.,  1.,  1.,  1.,  1.])
>>> print(res.message)
Optimization terminated successfully.
>>> res.hess_inv
array([[ 0.00749589,  0.01255155,  0.02396251,  0.04750988,  0.09495377],  # may vary
       [ 0.01255155,  0.02510441,  0.04794055,  0.09502834,  0.18996269],
       [ 0.02396251,  0.04794055,  0.09631614,  0.19092151,  0.38165151],
       [ 0.04750988,  0.09502834,  0.19092151,  0.38341252,  0.7664427 ],
       [ 0.09495377,  0.18996269,  0.38165151,  0.7664427,   1.53713523]])

>>> fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2

>>> cons = ({'type': 'ineq', 'fun': lambda x:  x[0] - 2 * x[1] + 2},
...         {'type': 'ineq', 'fun': lambda x: -x[0] - 2 * x[1] + 6},
...         {'type': 'ineq', 'fun': lambda x: -x[0] + 2 * x[1] + 2})

>>> bnds = ((0, None), (0, None))

>>> res = minimize(fun, (2, 0), method='SLSQP', bounds=bnds,
...                constraints=cons)

>>> from dipy.utils.optpkg import optional_package
>>> pkg, have_pkg, setup_module = optional_package('not_a_package')

>>> have_pkg
False

>>> pkg.some_function() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
    ...
TripWireError: We need package not_a_package for these functions, but
``import not_a_package`` raised an ImportError

>>> pkg, _, _ = optional_package('os')
>>> hasattr(pkg, 'path')
True

>>> subpkg, _, _ = optional_package('os.path')
>>> hasattr(subpkg, 'dirname')
True

>>> from dipy.core import rng
>>> rng.ix, rng.iy, rng.iz, rng.it = 100001, 200002, 300003, 400004
>>> N = 1000
>>> a = [rng.WichmannHill2006() for i in range(N)]

HemiSphere(x, y, z)
HemiSphere(xyz=xyz)
HemiSphere(theta=theta, phi=phi)

Sphere(x, y, z)
Sphere(xyz=xyz)
Sphere(theta=theta, phi=phi)

   y
   /               /               a/____
/\    /            /  \  /             /____\/____          x      c     z

>>> class MagicProp(object):
...     @auto_attr
...     def a(self):
...         return 99
...
>>> x = MagicProp()
>>> 'a' in x.__dict__
False
>>> x.a
99
>>> 'a' in x.__dict__
True

>>> euler_characteristic_check(unit_octahedron)
True
>>> hemisphere = HemiSphere.from_sphere(unit_icosahedron)
>>> euler_characteristic_check(hemisphere, chi=1)
True

   y
   /               /               a/    
/                  /                   /__________          x      c     z

>>> import numpy as np
>>> vec = [[8, 15, 0], [0, 36, 77]]
>>> vector_norm(vec)
array([ 17.,  85.])
>>> vector_norm(vec, keepdims=True)
array([[ 17.],
       [ 85.]])
>>> vector_norm(vec, axis=0)
array([  8.,  39.,  77.])

>>> import numpy as np
>>> from dipy.core.sphere_stats import angular_similarity
>>> S=np.array([[1,0,0],[0,1,0],[0,0,1]])
>>> T=np.array([[1,0,0],[0,0,1]])
>>> angular_similarity(S,T)
2.0
>>> T=np.array([[0,1,0],[1,0,0],[0,0,1]])
>>> S=np.array([[1,0,0],[0,0,1]])
>>> angular_similarity(S,T)
2.0
>>> S=np.array([[-1,0,0],[0,1,0],[0,0,1]])
>>> T=np.array([[1,0,0],[0,0,-1]])
>>> angular_similarity(S,T)
2.0
>>> T=np.array([[0,1,0],[1,0,0],[0,0,1]])
>>> S=np.array([[1,0,0],[0,1,0],[0,0,1]])
>>> angular_similarity(S,T)
3.0
>>> S=np.array([[0,1,0],[1,0,0],[0,0,1]])
>>> T=np.array([[1,0,0],[0,np.sqrt(2)/2.,np.sqrt(2)/2.],[0,0,1]])
>>> angular_similarity(S,T)
2.7071067811865475
>>> S=np.array([[0,1,0],[1,0,0],[0,0,1]])
>>> T=np.array([[1,0,0]])
>>> angular_similarity(S,T)
1.0
>>> S=np.array([[0,1,0],[1,0,0]])
>>> T=np.array([[0,0,1]])
>>> angular_similarity(S,T)
0.0
>>> S=np.array([[0,1,0],[1,0,0]])
>>> T=np.array([[0,np.sqrt(2)/2.,np.sqrt(2)/2.]])

>>> print('%.12f' % angular_similarity(S,T))
0.707106781187
>>> S=np.array([[0,1,0]])
>>> T=np.array([[0,np.sqrt(2)/2.,np.sqrt(2)/2.]])
>>> print('%.12f' % angular_similarity(S,T))
0.707106781187
>>> S=np.array([[0,1,0],[0,0,1]])
>>> T=np.array([[0,np.sqrt(2)/2.,np.sqrt(2)/2.]])
>>> print('%.12f' % angular_similarity(S,T))
0.707106781187

>>> from dipy.core.sphere_stats import compare_orientation_sets
>>> S=np.array([[1,0,0],[0,1,0],[0,0,1]])
>>> T=np.array([[1,0,0],[0,0,1]])
>>> compare_orientation_sets(S,T)
1.0
>>> T=np.array([[0,1,0],[1,0,0],[0,0,1]])
>>> S=np.array([[1,0,0],[0,0,1]])
>>> compare_orientation_sets(S,T)
1.0
>>> from dipy.core.sphere_stats import compare_orientation_sets
>>> S=np.array([[-1,0,0],[0,1,0],[0,0,1]])
>>> T=np.array([[1,0,0],[0,0,-1]])
>>> compare_orientation_sets(S,T)
1.0

>>> from dipy.core.sphere_stats import random_uniform_on_sphere
>>> X = random_uniform_on_sphere(4, 'radians')
>>> X.shape == (4, 2)
True
>>> X = random_uniform_on_sphere(4, 'xyz')
>>> X.shape == (4, 3)
True

HemiSphere(x, y, z)
HemiSphere(xyz=xyz)
HemiSphere(theta=theta, phi=phi)

`cart2sphere`(x, y, z)	Return angles for Cartesian 3D coordinates x, y, and z
`cart_distance`(pts1, pts2)	Cartesian distance between pts1 and pts2
`circumradius`(a, b, c)	a, b and c are 3-dimensional vectors which are the vertices of a triangle.
`compose_matrix`([scale, shear, angles, …])	Return 4x4 transformation matrix from sequence of transformations.
`compose_transformations`(*mats)	Compose multiple 4x4 affine transformations in one 4x4 matrix
`decompose_matrix`(matrix)	Return sequence of transformations from transformation matrix.
`dist_to_corner`(affine)	Calculate the maximal distance from the center to a corner of a voxel, given an affine
`euler_matrix`(ai, aj, ak[, axes])	Return homogeneous rotation matrix from Euler angles and axis sequence.
`is_hemispherical`(vecs)	Test whether all points on a unit sphere lie in the same hemisphere.
`lambert_equal_area_projection_cart`(x, y, z)	Lambert Equal Area Projection from cartesian vector to plane
`lambert_equal_area_projection_polar`(theta, phi)	Lambert Equal Area Projection from polar sphere to plane
`nearest_pos_semi_def`(B)	Least squares positive semi-definite tensor estimation
`normalized_vector`(vec[, axis])	Return vector divided by its Euclidean (L2) norm
`perpendicular_directions`(v[, num, half])	Computes n evenly spaced perpendicular directions relative to a given vector v
`rodrigues_axis_rotation`(r, theta)	Rodrigues formula
`sph2latlon`(theta, phi)	Convert spherical coordinates to latitude and longitude.
`sphere2cart`(r, theta, phi)	Spherical to Cartesian coordinates
`sphere_distance`(pts1, pts2[, radius, …])	Distance across sphere surface between pts1 and pts2
`vec2vec_rotmat`(u, v)	rotation matrix from 2 unit vectors
`vector_cosine`(vecs1, vecs2)	Cosine of angle between two (sets of) vectors
`vector_norm`(vec[, axis, keepdims])	Return vector Euclidean (L2) norm

`GradientTable`(gradients[, big_delta, …])	Diffusion gradient information
`HemiSphere`([x, y, z, theta, phi, xyz, …])	Points on the unit sphere.
`auto_attr`(func)	Decorator to create OneTimeProperty attributes.
`check_multi_b`(gtab, n_bvals[, non_zero, bmag])	Check if you have enough different b-values in your gradient table
`disperse_charges`(hemi, iters[, const])	Models electrostatic repulsion on the unit sphere
`generate_bvecs`(N[, iters])	Generates N bvectors.
`gradient_table`(bvals[, bvecs, big_delta, …])	A general function for creating diffusion MR gradients.
`gradient_table_from_bvals_bvecs`(bvals, bvecs)	Creates a GradientTable from a bvals array and a bvecs array
`gradient_table_from_gradient_strength_bvecs`(…)	A general function for creating diffusion MR gradients.
`gradient_table_from_qvals_bvecs`(qvals, …)	A general function for creating diffusion MR gradients.
`inv`(a[, overwrite_a, check_finite])	Compute the inverse of a matrix.
`polar`(a[, side])	Compute the polar decomposition.
`reorient_bvecs`(gtab, affines)	Reorient the directions in a GradientTable.
`round_bvals`(bvals[, bmag])	“This function rounds the b-values
`unique_bvals`(bvals[, bmag, rbvals])	This function gives the unique rounded b-values of the data
`vector_norm`(vec[, axis, keepdims])	Return vector Euclidean (L2) norm
`warn`	Issue a warning, or maybe ignore it or raise an exception.

`as_strided`(x[, shape, strides, subok, writeable])	Create a view into the array with the given shape and strides.
`ndindex`(shape)	An N-dimensional iterator object to index arrays.

`OneTimeProperty`(func)	A descriptor to make special properties that become normal attributes.
`ResetMixin`	A Mixin class to add a .reset() method to users of OneTimeProperty.
`auto_attr`(func)	Decorator to create OneTimeProperty attributes.

`NonNegativeLeastSquares`(args, *kwargs)	A sklearn-like interface to scipy.optimize.nnls
`Optimizer`(fun, x0[, args, method, jac, …])	Attributes
`SKLearnLinearSolver`(args, *kwargs)	Provide a sklearn-like uniform interface to algorithms that solve problems of the form: \(y = Ax\) for \(x\)
`minimize`(fun, x0[, args, method, jac, hess, …])	Minimization of scalar function of one or more variables.
`sparse_nnls`(y, X[, momentum, step_size, …])	Solve y=Xh for h, using gradient descent, with X a sparse matrix.
`spdot`(A, B)	The same as np.dot(A, B), except it works even if A or B or both are sparse matrices.

`Profiler`([call])	Profile python/cython files or functions
`optional_package`(name[, trip_msg])	Return package-like thing and module setup for package name

`LEcuyer`()	Generate uniformly distributed random numbers using the 32-bit generator from figure 3 of: L’Ecuyer, P.
`WichmannHill1982`()	Algorithm AS 183 Appl.
`WichmannHill2006`()	B.A.
`architecture`([executable, bits, linkage])	Queries the given executable (defaults to the Python interpreter binary) for various architecture information.
`floor`(x)	Return the floor of x as an Integral.

`HemiSphere`([x, y, z, theta, phi, xyz, …])	Points on the unit sphere.
`Sphere`([x, y, z, theta, phi, xyz, faces, edges])	Points on the unit sphere.
`auto_attr`(func)	Decorator to create OneTimeProperty attributes.
`cart2sphere`(x, y, z)	Return angles for Cartesian 3D coordinates x, y, and z
`disperse_charges`(hemi, iters[, const])	Models electrostatic repulsion on the unit sphere
`euler_characteristic_check`(sphere[, chi])	Checks the euler characteristic of a sphere
`faces_from_sphere_vertices`(vertices)	Triangulate a set of vertices on the sphere.
`remove_similar_vertices`	Remove vertices that are less than theta degrees from any other
`sphere2cart`(r, theta, phi)	Spherical to Cartesian coordinates
`unique_edges`(faces[, return_mapping])	Extract all unique edges from given triangular faces.
`unique_sets`(sets[, return_inverse])	Remove duplicate sets.
`vector_norm`(vec[, axis, keepdims])	Return vector Euclidean (L2) norm

`permutations`	permutations(iterable[, r]) –> permutations object
`angular_similarity`(S, T)	Computes the cosine distance of the best match between points of two sets of vectors S and T
`compare_orientation_sets`(S, T)	Computes the mean cosine distance of the best match between points of two sets of vectors S and T (angular similarity)
`eigenstats`(points[, alpha])	Principal direction and confidence ellipse
`random_uniform_on_sphere`([n, coords])	Random unit vectors from a uniform distribution on the sphere.

`HemiSphere`([x, y, z, theta, phi, xyz, …])	Points on the unit sphere.
`create_unit_hemisphere`([recursion_level])	Creates a unit sphere by subdividing a unit octahedron, returns half the sphere.
`create_unit_sphere`([recursion_level])	Creates a unit sphere by subdividing a unit octahedron.

`afb3D`(x, af1[, af2, af3])	3D Analysis Filter Bank
`afb3D_A`(x, af, d)	3D Analysis Filter Bank
`cshift3D`(x, m, d)	3D Circular Shift
`dwt3D`(x, J, af)	3-D Discrete Wavelet Transform
`idwt3D`(w, J, sf)	Inverse 3-D Discrete Wavelet Transform
`permutationinverse`(perm)	Function generating inverse of the permutation
`sfb3D`(lo, hi, sf1[, sf2, sf3])	3D Synthesis Filter Bank
`sfb3D_A`(lo, hi, sf, d)	3D Synthesis Filter Bank

b0s_mask
bvals
bvecs
gradient_strength
qvals
tau

`find_closest`(xyz)	Find the index of the vertex in the Sphere closest to the input vector, taking into account antipodal symmetry
`from_sphere`(sphere[, tol])	Create instance from a Sphere
`mirror`()	Create a full Sphere from a HemiSphere
`subdivide`([n])	Create a more subdivided HemiSphere

add_edge
add_node
all_paths
children
del_node
del_node_and_edges
down
down_short
parents
shortest_path
up
up_short

`fit`(X, y)	Fit the NonNegativeLeastSquares linear model to data
`predict`(X)	Predict using the result of the model

edges
faces
vertices

edges
faces
vertices

edges
faces
vertices

edges
faces
vertices

`fit`(X, y)	Implement for all derived classes
`predict`(X)	Predict using the result of the model

core¶

Module: core.geometry¶

Module: core.gradients¶

Module: core.graph¶

Module: core.histeq¶

Module: core.ndindex¶

Module: core.onetime¶

References¶

Module: core.optimize¶

Module: core.profile¶

Module: core.rng¶

Module: core.sphere¶

Module: core.sphere_stats¶

Module: core.subdivide_octahedron¶

Module: core.wavelet¶

test¶

cart2sphere¶

cart_distance¶

circumradius¶

compose_matrix¶

compose_transformations¶

decompose_matrix¶

dist_to_corner¶

euler_matrix¶

is_hemispherical¶

lambert_equal_area_projection_cart¶

lambert_equal_area_projection_polar¶

nearest_pos_semi_def¶

normalized_vector¶

perpendicular_directions¶

rodrigues_axis_rotation¶

sph2latlon¶

sphere2cart¶

sphere_distance¶

vec2vec_rotmat¶

vector_cosine¶

vector_norm¶

auto_attr¶

check_multi_b¶

disperse_charges¶

generate_bvecs¶

gradient_table¶

gradient_table_from_bvals_bvecs¶

gradient_table_from_gradient_strength_bvecs¶

gradient_table_from_qvals_bvecs¶

inv¶

polar¶

reorient_bvecs¶

round_bvals¶

unique_bvals¶

vector_norm¶

warn¶

histeq¶

as_strided¶

ndindex¶

auto_attr¶

minimize¶

sparse_nnls¶

spdot¶

optional_package¶

LEcuyer¶

WichmannHill1982¶

WichmannHill2006¶

architecture¶

floor¶

auto_attr¶

cart2sphere¶

disperse_charges¶

euler_characteristic_check¶

faces_from_sphere_vertices¶

remove_similar_vertices¶

sphere2cart¶

unique_edges¶

unique_sets¶

vector_norm¶

angular_similarity¶

compare_orientation_sets¶

eigenstats¶

random_uniform_on_sphere¶

create_unit_hemisphere¶

`core`¶

Module: `core.geometry`¶

Module: `core.gradients`¶

Module: `core.graph`¶

Module: `core.histeq`¶

Module: `core.ndindex`¶

Module: `core.onetime`¶

Module: `core.optimize`¶

Module: `core.profile`¶

Module: `core.rng`¶

Module: `core.sphere`¶

Module: `core.sphere_stats`¶

Module: `core.subdivide_octahedron`¶

Module: `core.wavelet`¶