java.lang.Object
- org.robwork.sdurw_math.Rotation3DVector
- - org.robwork.sdurw_math.EAA

```
public class EAA
extends Rotation3DVector
```
A class for representing an equivalent angle-axis rotation

This class defines an equivalent-axis-angle orientation vector also known
as an \thetak vector or "axis+angle" vector

The equivalent-axis-angle vector is the product of a unit vector \hat{\mathbf{k}} and an angle of rotation around that axis \theta

Note: given two EAA vectors \theta_1\mathbf{\hat{k}}_1 and \theta_2\mathbf{\hat{k}}_2 it is generally not possible to subtract
or add these vectors, except for the special case when \mathbf{\hat{k}}_1 == \mathbf{\hat{k}}_2 this is why this class does
not have any subtraction or addition operators

Constructor Summary

Constructors
Constructor	Description
`EAA()`	Constructs an EAA vector initialized to \{0,0,0\}
`EAA(double thetakx, double thetaky, double thetakz)`	Constructs an initialized EAA vector \thetak = \left[\begin{array}{c} \theta k_x\\ \theta k_y\\ \theta k_z \end{array}\right]
`EAA(long cPtr, boolean cMemoryOwn)`
`EAA(EAA eaa)`	Copy Constructor
`EAA(Rotation3D R)`	Extracts Equivalent axis-angle vector from Rotation matrix
`EAA(Vector3D eaa)`	Constructs an initialized EAA vector The angle of the EAA are \\|eaa\\| and the axis is \frac{eaa}{\\|eaa\\|}
`EAA(Vector3D axis, double angle)`	Constructs an initialized EAA vector
`EAA(Vector3D v1, Vector3D v2)`	Constructs an EAA vector that will rotate v1 into v2.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`EAA`	`add(Vector3D rhs)`	element wise multiplication.
`EAA`	`addAssign(Vector3D rhs)`	addition operator
`double`	`angle()`	Extracts the angle of rotation \theta
`Vector3D`	`axis()`	Extracts the axis of rotation vector \mathbf{\hat{\mathbf{k}}}
`EAA`	`copy(EAA rhs)`	copy operator
`EAA`	`copy(Rotation3D rhs)`	copy operator
`EAA`	`copy(Vector3D rhs)`	assign vector to EAA
`EAA`	`cross(EAA eaa)`	Calculates the cross product and returns the result
`Vector3D`	`cross(Vector3D v)`	Calculates the cross product and returns the result
`void`	`delete()`
`double`	`dot(EAA eaa)`	Calculates the cross product and returns the result
`double`	`dot(Vector3D v)`	Calculates the dot product and returns the result
`EigenVector3d`	`e()`	get as eigen vector
`EAA`	`elemAdd(double rhs)`	Scalar addition.
`EAA`	`elemAdd(EAA rhs)`	element wise addition
`EAA`	`elemDivide(double rhs)`	scalar devision
`EAA`	`elemDivide(EAA rhs)`	element wise devision ( this / rhs )
`EAA`	`elemDivide(Vector3D rhs)`	element wise devision ( this / rhs )
`EAA`	`elemMultiply(double rhs)`	scalar multiplication
`EAA`	`elemMultiply(EAA rhs)`	element wise multiplication
`EAA`	`elemMultiply(Vector3D rhs)`	element wise multiplication
`EAA`	`elemSubtract(double rhs)`	Scalar subtraction.
`EAA`	`elemSubtract(EAA rhs)`	element wise subtraction
`boolean`	`equals(EAA rhs)`	Compare with rhs for equality.
`boolean`	`equals(Vector3D rhs)`	Compare with rhs for equality.
`double`	`get(long i)`
`static long`	`getCPtr(EAA obj)`
`EAA`	`multiply(EAA rhs)`	This is rotation multiplcation, and it is multiplication of two EAA's first converted to a Rotation3D
`EAA`	`negate()`	Unary minus. negative version
`double`	`norm1()`	Returns the Manhatten norm (1-norm) of the vector
`double`	`norm2()`	Returns the Euclidean norm (2-norm) of the vector
`double`	`normInf()`	Returns the infinte norm ( \inf-norm) of the vector
`boolean`	`notEqual(EAA rhs)`	Compare with rhs for inequality.
`boolean`	`notEqual(Vector3D rhs)`	Compare with rhs for inequality.
`EAA`	`scaleAngle(double scale)`	scale the angle, keeping the axis the same
`void`	`set(long i, double d)`
`EAA`	`setAngle(double angle)`	change the angle of the EAA
`long`	`size()`	Get the size of the EAA.
`EAA`	`subtract(Vector3D rhs)`	Vector addition
`EAA`	`subtractAssign(Vector3D rhs)`	subtraction operator
`Rotation3D`	`toRotation3D()`	Returns the corresponding 3\times 3 Rotation matrix
`java.lang.String`	`toString()`
`Vector3D`	`toVector3D()`	get the underling Vector

Methods inherited from class org.robwork.sdurw_math.Rotation3DVector
getCPtr

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - EAA
```
public EAA(long cPtr,
           boolean cMemoryOwn)
```
  - EAA
```
public EAA(Rotation3D R)
```
    Extracts Equivalent axis-angle vector from Rotation matrix
    
    Parameters:
    
    R - [in] A 3x3 rotation matrix \mathbf{R}
    
    \theta = arccos(\frac{1}{2}(Trace(\mathbf{R})-1)=arccos(\frac{r_{11}+r_{22}+r_{33}-1}{2})
    
    \thetak=log(\mathbf{R})=\frac{\theta}{2 sin \theta}(\mathbf{R}-\mathbf{R}^T) = \frac{\theta}{2 sin \theta} \left[ \begin{array}{c} r_{32}-r_{23}\\ r_{13}-r_{31}\\ r_{21}-r_{12} \end{array} \right]
    
    \thetak= \left[ \begin{array}{c} 0\\ 0\\ 0 \end{array} \right] if \theta = 0
    
    \thetak=\pi \left[ \begin{array}{c} \sqrt{(R(0,0)+1.0)/2.0}\\ \sqrt{(R(1,1)+1.0)/2.0}\\ \sqrt{(R(2,2)+1.0)/2.0} \end{array} \right] if \theta = \pi
  - EAA
```
public EAA()
```
    Constructs an EAA vector initialized to \{0,0,0\}
  - EAA
```
public EAA(Vector3D axis,
           double angle)
```
    Constructs an initialized EAA vector
    
    Parameters:
    
    axis - [in] \mathbf{\hat{k}}
    
    angle - [in] \theta
  - EAA
```
public EAA(double thetakx,
           double thetaky,
           double thetakz)
```
    Constructs an initialized EAA vector
    \thetak = \left[\begin{array}{c} \theta k_x\\ \theta k_y\\ \theta k_z \end{array}\right]
    
    Parameters:
    
    thetakx - [in] \theta k_x
    
    thetaky - [in] \theta k_y
    
    thetakz - [in] \theta k_z
  - EAA
```
public EAA(Vector3D v1,
           Vector3D v2)
```
    Constructs an EAA vector that will rotate v1 into
    v2. Where v1 and v2 are normalized and described in the same reference frame.
    
    Parameters:
    
    v1 - [in] normalized vector
    
    v2 - [in] normalized vector
  - EAA
```
public EAA(Vector3D eaa)
```
    Constructs an initialized EAA vector
    
    The angle of the EAA are \|eaa\| and the axis is \frac{eaa}{\|eaa\|}
    
    Parameters:
    
    eaa - [in] Values to initialize the EAA
  - EAA
```
public EAA(EAA eaa)
```
    Copy Constructor
    
    Parameters:
    
    eaa - [in] Values to initialize the EAA
- Method Detail
  - getCPtr
```
public static long getCPtr(EAA obj)
```
  - delete
```
public void delete()
```
    Overrides:
    
    delete in class Rotation3DVector
  - size
```
public long size()
```
    Get the size of the EAA.
    
    Returns:
    
    the size (always 3).
  - toRotation3D
```
public Rotation3D toRotation3D()
```
    Description copied from class: Rotation3DVector
    
    Returns the corresponding 3\times 3 Rotation matrix
    
    Overrides:
    
    toRotation3D in class Rotation3DVector
    
    Returns:
    
    The rotation matrix
  - angle
```
public double angle()
```
    Extracts the angle of rotation \theta
    
    Returns:
    
    \theta
  - setAngle
```
public EAA setAngle(double angle)
```
    change the angle of the EAA
    
    Parameters:
    
    angle - [in] the new angle
    
    Returns:
    
    this object
  - axis
```
public Vector3D axis()
```
    Extracts the axis of rotation vector \mathbf{\hat{\mathbf{k}}}
    
    Returns:
    
    \mathbf{\hat{\mathbf{k}}}
  - toVector3D
```
public Vector3D toVector3D()
```
    get the underling Vector
    
    Returns:
    
    the vector
  - e
```
public EigenVector3d e()
```
    get as eigen vector
    
    Returns:
    
    Eigenvector
  - get
```
public double get(long i)
```
  - set
```
public void set(long i,
                double d)
```
  - negate
```
public EAA negate()
```
    Unary minus.
    negative version
  - elemAdd
```
public EAA elemAdd(EAA rhs)
```
    element wise addition
    
    Parameters:
    
    rhs - [in] the EAA to be added
    
    Returns:
    
    the sum of the two EAA's
  - elemSubtract
```
public EAA elemSubtract(EAA rhs)
```
    element wise subtraction
    
    Parameters:
    
    rhs - [in] the EAA to be subtracted
    
    Returns:
    
    the difference between the two EAA's
  - elemDivide
```
public EAA elemDivide(EAA rhs)
```
    element wise devision ( this / rhs )
    
    Parameters:
    
    rhs - [in] the EAA to be devided with
    
    Returns:
    
    the result of division
  - elemMultiply
```
public EAA elemMultiply(EAA rhs)
```
    element wise multiplication
    
    Parameters:
    
    rhs - [in] the EAA to be multiplyed with
    
    Returns:
    
    the result of division
  - multiply
```
public EAA multiply(EAA rhs)
```
    This is rotation multiplcation, and it is multiplication of two EAA's first
    converted to a Rotation3D
    
    Parameters:
    
    rhs - [in] the eaa to multiply with
    
    Returns:
    
    the new rotation
  - elemMultiply
```
public EAA elemMultiply(double rhs)
```
    scalar multiplication
    
    Parameters:
    
    rhs - [in] the scalar to multiply with
    
    Returns:
    
    the product
  - elemDivide
```
public EAA elemDivide(double rhs)
```
    scalar devision
    
    Parameters:
    
    rhs - [in] the scalar to devide with
    
    Returns:
    
    the resulting EAA
  - elemSubtract
```
public EAA elemSubtract(double rhs)
```
    Scalar subtraction.
  - elemAdd
```
public EAA elemAdd(double rhs)
```
    Scalar addition.
  - scaleAngle
```
public EAA scaleAngle(double scale)
```
    scale the angle, keeping the axis the same
    
    Parameters:
    
    scale - [in] how much the angle should change
    
    Returns:
    
    a new EAA with the scaled angle
  - add
```
public EAA add(Vector3D rhs)
```
    element wise multiplication.
    
    Parameters:
    
    rhs - [in] the vector being devided with
    
    Returns:
    
    the resulting EAA
  - subtract
```
public EAA subtract(Vector3D rhs)
```
    Vector addition
    
    Parameters:
    
    rhs - [in] the vector being added
    
    Returns:
    
    the resulting EAA
  - elemDivide
```
public EAA elemDivide(Vector3D rhs)
```
    element wise devision ( this / rhs )
    
    Parameters:
    
    rhs - [in] the Vector to be devided with
    
    Returns:
    
    the result of division
  - elemMultiply
```
public EAA elemMultiply(Vector3D rhs)
```
    element wise multiplication
    
    Parameters:
    
    rhs - [in] the Vector to be multiplyed with
    
    Returns:
    
    the result of division
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - cross
```
public Vector3D cross(Vector3D v)
```
    Calculates the cross product and returns the result
    
    Parameters:
    
    v - [in] a Vector3D
    
    Returns:
    
    the resulting 3D vector
  - cross
```
public EAA cross(EAA eaa)
```
    Calculates the cross product and returns the result
    
    Parameters:
    
    eaa - [in] a EAA
    
    Returns:
    
    the resulting 3D vector
  - dot
```
public double dot(Vector3D v)
```
    Calculates the dot product and returns the result
    
    Parameters:
    
    v - [in] a Vector3D
    
    Returns:
    
    the resulting scalar
  - dot
```
public double dot(EAA eaa)
```
    Calculates the cross product and returns the result
    
    Parameters:
    
    eaa - [in] a EAA
    
    Returns:
    
    the resulting 3D vector
  - norm2
```
public double norm2()
```
    Returns the Euclidean norm (2-norm) of the vector
    
    Returns:
    
    the norm
  - norm1
```
public double norm1()
```
    Returns the Manhatten norm (1-norm) of the vector
    
    Returns:
    
    the norm
  - normInf
```
public double normInf()
```
    Returns the infinte norm ( \inf-norm) of the vector
    
    Returns:
    
    the norm
  - copy
```
public EAA copy(EAA rhs)
```
    copy operator
    
    Parameters:
    
    rhs - [in] the EAA to be copied
    
    Returns:
    
    reference to this EAA
  - copy
```
public EAA copy(Vector3D rhs)
```
    assign vector to EAA
    
    Parameters:
    
    rhs - [in] the vector to asign
    
    Returns:
    
    reference to this EAA
  - addAssign
```
public EAA addAssign(Vector3D rhs)
```
    addition operator
    
    Parameters:
    
    rhs - [in] the right hand side of the operation
    
    Returns:
    
    reference to this EAA
  - subtractAssign
```
public EAA subtractAssign(Vector3D rhs)
```
    subtraction operator
    
    Parameters:
    
    rhs - [in] the right hand side of the operation
    
    Returns:
    
    reference to this EAA
  - copy
```
public EAA copy(Rotation3D rhs)
```
    copy operator
    
    Parameters:
    
    rhs - [in] the Rotation3D to be copied
    
    Returns:
    
    reference to this EAA
  - equals
```
public boolean equals(Vector3D rhs)
```
    Compare with rhs for equality.
    
    Parameters:
    
    rhs - [in] other vector.
    
    Returns:
    
    True if a equals b, false otherwise.
  - notEqual
```
public boolean notEqual(Vector3D rhs)
```
    Compare with rhs for inequality.
    
    Parameters:
    
    rhs - [in] other vector.
    
    Returns:
    
    True if a and b are different, false otherwise.
  - equals
```
public boolean equals(EAA rhs)
```
    Compare with rhs for equality.
    
    Parameters:
    
    rhs - [in] other vector.
    
    Returns:
    
    True if a equals b, false otherwise.
  - notEqual
```
public boolean notEqual(EAA rhs)
```
    Compare with rhs for inequality.
    
    Parameters:
    
    rhs - [in] other vector.
    
    Returns:
    
    True if a and b are different, false otherwise.

Class EAA

Constructor Summary

Method Summary

Methods inherited from class org.robwork.sdurw_math.Rotation3DVector

Methods inherited from class java.lang.Object

Constructor Detail

EAA

EAA

EAA

EAA

EAA

EAA

EAA

EAA

Method Detail

getCPtr

delete

size

toRotation3D

angle

setAngle

axis

toVector3D

e

get

set

negate

elemAdd

elemSubtract

elemDivide

elemMultiply

multiply

elemMultiply

elemDivide

elemSubtract

elemAdd

scaleAngle

add

subtract

elemDivide

elemMultiply

toString

cross

cross

dot

dot

norm2

norm1

normInf

copy

copy

addAssign

subtractAssign

copy

equals

notEqual

equals

notEqual