def __init__(self, arg=None, *, unit='rad', check=True):
"""
Construct new SO(2) object
:param unit: angular units 'deg' or 'rad' [default] if applicable
:type unit: str, optional
:param check: check for valid SO(2) elements if applicable, default to True
:type check: bool
:return: SO(2) rotation
:rtype: SO2 instance
- ``SO2()`` is an SO2 instance representing a null rotation -- the identity matrix.
- ``SO2(θ)`` is an SO2 instance representing a rotation by ``θ`` radians. If ``θ`` is array_like
`[θ1, θ2, ... θN]` then an SO2 instance containing a sequence of N rotations.
- ``SO2(θ, unit='deg')`` is an SO2 instance representing a rotation by ``θ`` degrees. If ``θ`` is array_like
`[θ1, θ2, ... θN]` then an SO2 instance containing a sequence of N rotations.
- ``SO2(R)`` is an SO2 instance with rotation described by the SO(2) matrix R which is a 2x2 numpy array. If ``check``
is ``True`` check the matrix belongs to SO(2).
- ``SO2([R1, R2, ... RN])`` is an SO2 instance containing a sequence of N rotations, each described by an SO(2) matrix
Ri which is a 2x2 numpy array. If ``check`` is ``True`` then check each matrix belongs to SO(2).
- ``SO2([X1, X2, ... XN])`` is an SO2 instance containing a sequence of N rotations, where each Xi is an SO2 instance.
"""
if super().arghandler(arg, check=check):
return
elif argcheck.isscalar(arg):
self.data = [tr.rot2(arg, unit=unit)]
elif argcheck.isvector(arg):
self.data = [tr.rot2(x, unit=unit) for x in argcheck.getvector(arg)]
else:
raise ValueError('bad argument to constructor')
def __init__(self, arg = None, *, unit='rad'):
super().__init__() # activate the UserList semantics
if arg is None:
# empty constructor
self.data = [np.eye(2)]
elif argcheck.isvector(arg):
# SO2(value)
# SO2(list of values)
self.data = [tr.rot2(x, unit) for x in argcheck.getvector(arg)]
else:
super().arghandler(arg)
def __init__(self, arg=None, *, unit='rad'):
super().__init__() # activate the UserList semantics
if arg is None:
# empty constructor
if type(self) is SO2:
self.data = [np.eye(2)]
elif argcheck.isvector(arg):
# SO2(value)
# SO2(list of values)
self.data = [tr.rot2(x, unit) for x in argcheck.getvector(arg)]
elif isinstance(arg, np.ndarray) and arg.shape == (2, 2):
self.data = [arg]
else:
super().arghandler(arg)
def __init__(self, arg=None, *, unit='rad', check=True):
"""
Construct new SO(2) object
:param unit: angular units 'deg' or 'rad' [default] if applicable
:type unit: str, optional
:param check: check for valid SO(2) elements if applicable, default to True
:type check: bool
:return: SO(2) rotation
:rtype: SO2 instance
- ``SO2()`` is an SO2 instance representing a null rotation -- the identity matrix.
- ``SO2(theta)`` is an SO2 instance representing a rotation by ``theta`` radians. If ``theta`` is array_like
`[theta1, theta2, ... thetaN]` then an SO2 instance containing a sequence of N rotations.
- ``SO2(theta, unit='deg')`` is an SO2 instance representing a rotation by ``theta`` degrees. If ``theta`` is array_like
`[theta1, theta2, ... thetaN]` then an SO2 instance containing a sequence of N rotations.
- ``SO2(R)`` is an SO2 instance with rotation described by the SO(2) matrix R which is a 2x2 numpy array. If ``check``
is ``True`` check the matrix belongs to SO(2).
- ``SO2([R1, R2, ... RN])`` is an SO2 instance containing a sequence of N rotations, each described by an SO(2) matrix
Ri which is a 2x2 numpy array. If ``check`` is ``True`` then check each matrix belongs to SO(2).
- ``SO2([X1, X2, ... XN])`` is an SO2 instance containing a sequence of N rotations, where each Xi is an SO2 instance.
"""
super().__init__() # activate the UserList semantics
if arg is None:
# empty constructor
if type(self) is SO2:
self.data = [np.eye(2)]
elif argcheck.isvector(arg):
# SO2(value)
# SO2(list of values)
self.data = [tr.rot2(x, unit) for x in argcheck.getvector(arg)]
elif isinstance(arg, np.ndarray) and arg.shape == (2, 2):
self.data = [arg]
else:
super()._arghandler(arg, check=check)
def Rand(cls, N=1, arange=(0, 2 * math.pi), unit='rad'):
r"""
Construct new SO(2) with random rotation
:param arange: rotation range, defaults to :math:`[0, 2\pi)`.
:type arange: 2-element array-like, optional
:param unit: angular units as 'deg or 'rad' [default]
:type unit: str, optional
:param N: number of random rotations, defaults to 1
:type N: int
:return: SO(2) rotation matrix
:rtype: SO2 instance
- ``SO2.Rand()`` is a random SO(2) rotation.
- ``SO2.Rand([-90, 90], unit='deg')`` is a random SO(2) rotation between
-90 and +90 degrees.
- ``SO2.Rand(N)`` is a sequence of N random rotations.
Rotations are uniform over the specified interval.
"""
rand = np.random.uniform(low=arange[0], high=arange[1], size=N) # random values in the range
return cls([base.rot2(x) for x in argcheck.getunit(rand, unit)])
def rand(cls, *, range=[0, 2 * math.pi], unit='rad', N=1):
rand = np.random.uniform(low=range[0], high=range[1],
size=N) # random values in the range
return cls([tr.rot2(x) for x in argcheck.getunit(rand, unit)])