Module spheres

Returns a direction distant from both *s* and *-s*.

:param s: :type s: ``direction``

:rtype: ``direction``

Returns any axis orthogonal to *s* (not necessarily random).

:param s: :type s: ``direction``

:rtype: ``direction``

Checks that two vectors are orthogonal.

:param s: :type s: ``array[K],K>=2``

:param v: :type v: ``array[K]``

       Returns the axis to use when any will do. 
       
       For example, the identity is represented by
       a rotation of 0 degrees around *any* axis. If an *(axis,angle)*
       representation is requested, the axis will be given by
       *default_axis()*. 
   


:rtype:  ``direction``

       Returns an axis orthogonal to the one returned 
       by :py:func:`default_axis`. 
       
       Use this when you need a couple of arbitrary orthogonal axes.
   


:rtype:  ``direction``

Checks that every column has unit length.

:param X: :type X: ``array[KxN],K>0,N>0``

       Returns the geodesic distances on the sphere from a set of
       points *S* to a given point *s*. 
       
   


:param s: 
:type s:  ``direction``

:param S: 
:type S:  ``array[3xK],directions``

:rtype:  ``array[K](>=0,<=pi)``

       Returns the radius of the given directions distribution.
       
       The radius is defined as the minimum *r* such that there exists a 
       point *s* in *S* such that all distances are within *r* from *s*. 
       
       .. math:: \textsf{radius} = \min \{ r | \exists s : 
                 \forall x \in S : d(s,x) <= r \}
   


:param S: 
:type S:  ``directions``

:rtype:  ``float,>=0,<=pi``

Returns the geodesic distance between two points on the sphere.

:param s2: :type s2: ``array[K],unit_length``

:param s1: :type s1: ``array[K],unit_length``

:rtype: ``float,>=0,<=pi``

Normalizes the entries in *x* in the interval :math:`[-pi,pi)`.

:param x: :type x: ``array[N]``

:rtype: ``array[N](>=-pi,<pi)``

:param x: :type x: ``float``

:rtype: ``>=-pi,<pi``

:param S: :type S: ``array[KxN],K>=2``

:rtype: ``array[KxN]``

       Generates a random direction in :math:`\sphere^{\ndim-1}`. 
   
       Currently only implemented for 2D and 3D.
   


:param ndim: 
:type ndim:  ``(2|3),K``

:rtype:  ``array[K],unit_length``

Returns a set of random directions.

:param ndim: :type ndim: ``2|3``

:param N: :type N: ``int,>0,N``

:rtype: ``array[3xN]``

       Returns a random distribution of points in :math:`\sphere^{\ndim-1}`.
       within a certain radius from the point *center*. 
       
       The points will be distributed uniformly in that area of the sphere.
       If *center* is not passed, it will be a random direction. 
   


:param ndim: 
:type ndim:  ``(2|3),K``

:param num_points: 
:type num_points:  ``int,>0``

:param radius: 
:type radius:  ``number,>0,<=pi``

:param center: 
:type center:  ``None|array[K],unit_length``

:rtype:  ``array[KxN],directions``

       Returns a random axis orthogonal to *s* 
       (only implemented for circle and sphere). 
   


:param s: 
:type s:  ``array[K],unit_length,(K=2|K=3)``

:rtype:  ``array[K],unit_length``

Spherical interpolation between two points on a hypersphere.

:param s2: :type s2: ``array[K],unit_length``

:param s1: :type s1: ``array[K],unit_length``

:param t: :type t: ``number,>=0,<=1``

       Rearranges the directions in *S* in a better order for visualization.
   
       In 2D, sorts the directions using their angle. 
       
       In 3D, it tries to do a pleasant elicoidal arrangement 
       with **num_around** spires.
       
   


:param S: 
:type S:  ``array[KxN],(K=2|K=3),directions``

:rtype:  ``array[KxN],directions``

Returns the area of a spherical cap on the unit sphere of the given radius.

See figure at http://mathworld.wolfram.com/SphericalCap.html

Returns the radius of a spherical cap of the given area.

See http://www.springerlink.com/content/3521h167300g7v62/

Checks that the value is a 1D vector with unit length in the 2 norm.

:param x: :type x: ``array[N],N>0``