pub fn conjugate(&self) -> Self {
        Self::new(
            self.data[0], 
            -self.data[1], -self.data[2], -self.data[3],
            -self.data[4], -self.data[5], -self.data[6],
            self.data[7]
        )
    }
/// Compute the conjugate of a multivector.
/// 
/// The conjugate of a three-dimensional multivector `mv`, for each grade of 
/// multivector is given by
/// ```text
/// When mv is a scalar, conj(mv) := mv
/// When mv is a vector, conj(mv) := -mv
/// When mv is a bivector, conj(mv) := -mv
/// When mv is a trivector, conj(mv) := mv
/// ```
/// The conjugate of a three-dimensional multivector extends to an arbitrary 
/// multivector `mv` by linearity. Let `mv = a + v + B + T` be an arbitrary
/// three-dimensional Euclidean multivector where `a` is a scalar, `v` is a 
/// vector, `B` is a bivector, and `T` is a trivector. Then the conjugate of 
/// `mv` is given by
/// ```text
/// conj(mv) = conj(a + v + B + T)
///          = conj(a) + conj(v) + conj(B) + conj(T)
///          = a + (-v) + (-B) + T
///          = a - v - B + T
/// ```
/// 
/// # Conjugate In Euclidean Space
/// 
/// The conjugate of each basis blade in the basis 
/// `{1, e1, e2, e3, e12, e23, e31, e123}` are given by
/// ```text
/// conj(1)    = 1
/// conj(e1)   = -e1
/// conj(e2)   = -e2
/// conj(e3)   = -e3
/// conj(e12)  = -e12
/// conj(e23)  = -e23
/// conj(e31)  = -e31
/// conj(e123) = e123
/// ```
/// Let `mv = a0 + a1 * e1 + a2 * e2 + a3 * e3 + a12 * e12 + a23 * e23 + a31 * e31 + a123 * e123`
/// be a general multivector. The conjugate of `mv` is given by
/// ```text
/// conj(mv) = conj(a0 + a1 * e1 + a2 * e2 + a3 * e3 + a12 * e12 + a23 * e23 + a31 * e31 + a123 * e123)
///          = conj(a0) + conj(a1 * e1) + conj(a2 * e2) + conj(a3 * e3)
///                     + conj(a12 * e12) + conj(a23 * e23) + conj(a31 * e31)
///                     + conj(a123 * e123)
///          = a0 + a1 * conj(e1) + a2 * conj(e2) + a3 * conj(e3)
///               + a12 * conj(e12) + a23 * conj(e23) + a31 * conj(e31)
///               + a123 * conj(e123)
///          = a0 + a1 * (-e1) + a2 * (-e2) + a3 * (-e3)
///               + a12 * (-e12) + a23 * (-e23) + a31 * (-e31)
///               + a123 * e123
///          = a0 - a1 * e1 - a2 * e2 - a3 * e3
///               - a12 * e12  - a23 * e23 - a31 * e31
///               + a123 * e123
/// ```
/// We illustrate this with an example.
/// 
/// # Example
/// 
/// ```
/// # use cggeomalg::e3ga::{
/// #     EuclideanMultivector3,
/// # };
/// #
/// let mv = EuclideanMultivector3::new(
///     1_i32, 2_i32, 3_i32, 4_i32, 5_i32, 6_i32, 7_i32, 8_i32
/// );
/// let expected = EuclideanMultivector3::new(
///     1_i32, -2_i32, -3_i32, -4_i32, -5_i32, -6_i32, -7_i32, 8_i32
/// );
/// let result = mv.conjugate();
/// 
/// assert_eq!(result, expected);
/// ```
Compute the conjugate of a multivector.
Compute the conjugate of a multivector .
pub fn conjugate(&self) -> Self {
        Self::new(
            self.data[0], 
            -self.data[1], -self.data[2], -self.data[3],
            -self.data[4], -self.data[5], -self.data[6],
            self.data[7]
        )
    }
pub fn conjugate ( & self ) -> Self { Self :: new ( self . data [ 0 ] , - self . data [ 1 ] , - self . data [ 2 ] , - self . data [ 3 ] , - self . data [ 4 ] , - self . data [ 5 ] , - self . data [ 6 ] , self . data [ 7 ] ) }
Compute the conjugate of a multivector.
Compute the conjugate of a multivector .
&self
conjugate in euclidean space
None
example
None
use cggeomalg::e3ga::{
None
euclideanmultivector3,
None
};


assert_eq!(result, expected);
```
assert_eq! ( result expected ) ; ` ` `