You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
491 lines
275 KiB
491 lines
275 KiB
5 years ago
|
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="API documentation for the Rust `Quaternion` struct in crate `nalgebra`."><meta name="keywords" content="rust, rustlang, rust-lang, Quaternion"><title>nalgebra::geometry::Quaternion - Rust</title><link rel="stylesheet" type="text/css" href="../../normalize.css"><link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../dark.css"><link rel="stylesheet" type="text/css" href="../../light.css" id="themeStyle"><script src="../../storage.js"></script><noscript><link rel="stylesheet" href="../../noscript.css"></noscript><link rel="shortcut icon" href="http://nalgebra.org/img/favicon.ico"><style type="text/css">#crate-search{background-image:url("../../down-arrow.svg");}</style></head><body class="rustdoc struct"><!--[if lte IE 8]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu">☰</div><a href='../../nalgebra/index.html'><div class='logo-container'><img src='../../rust-logo.png' alt='logo'></div></a><p class='location'>Struct Quaternion</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#fields">Fields</a><div class="sidebar-links"><a href="#structfield.coords">coords</a></div><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.acos">acos</a><a href="#method.acosh">acosh</a><a href="#method.as_vector">as_vector</a><a href="#method.as_vector_mut">as_vector_mut</a><a href="#method.asin">asin</a><a href="#method.asinh">asinh</a><a href="#method.atan">atan</a><a href="#method.atanh">atanh</a><a href="#method.clone_owned">clone_owned</a><a href="#method.conjugate">conjugate</a><a href="#method.conjugate_mut">conjugate_mut</a><a href="#method.cos">cos</a><a href="#method.cosh">cosh</a><a href="#method.dot">dot</a><a href="#method.exp">exp</a><a href="#method.exp_eps">exp_eps</a><a href="#method.from_imag">from_imag</a><a href="#method.from_parts">from_parts</a><a href="#method.from_polar_decomposition">from_polar_decomposition</a><a href="#method.from_real">from_real</a><a href="#method.from_vector">from_vector</a><a href="#method.half">half</a><a href="#method.identity">identity</a><a href="#method.imag">imag</a><a href="#method.inner">inner</a><a href="#method.into_owned">into_owned</a><a href="#method.is_pure">is_pure</a><a href="#method.left_div">left_div</a><a href="#method.lerp">lerp</a><a href="#method.ln">ln</a><a href="#method.magnitude">magnitude</a><a href="#method.magnitude_squared">magnitude_squared</a><a href="#method.new">new</a><a href="#method.norm">norm</a><a href="#method.norm_squared">norm_squared</a><a href="#method.normalize">normalize</a><a href="#method.normalize_mut">normalize_mut</a><a href="#method.outer">outer</a><a href="#method.polar_decomposition">polar_decomposition</a><a href="#method.powf">powf</a><a href="#method.project">project</a><a href="#method.pure">pure</a><a href="#method.reject">reject</a><a href="#method.right_div">right_div</a><a href="#method.scalar">scalar</a><a href="#method.sin">sin</a><a href="#method.sinh">sinh</a><a href="#method.sqrt">sqrt</a><a href="#method.squared">squared</a><a href="#method.tan">tan</a><a href="#method.tanh">tanh</a><a href="#method.try_inverse">try_inverse</a><a href="#method.try_inverse_mut">try_inverse_mut</a><a href="#method.vector">vector</a><a href="#method.vector_mut">vector_mut</a></div><a class="sidebar-title" href="#deref-methods">Methods from Deref<Target=IJKW<N>></a><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-AbsDiffEq%3CQuaternion%3CN%3E%3E">AbsDiffEq<Quaternion<N>></a><a href="#impl-AbstractGroup%3CAdditive%3E">AbstractGroup<Additive></a><a href="#impl-AbstractGroupAbelian%3CAddi
|
||
|
|
</span>pub struct Quaternion<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> {
|
||
|
|
pub coords: <a class="type" href="../../nalgebra/base/type.Vector4.html" title="type nalgebra::base::Vector4">Vector4</a><N>,
|
||
|
|
}</pre></div><div class='docblock'><p>A quaternion. See the type alias <code>UnitQuaternion = Unit<Quaternion></code> for a quaternion
|
||
|
|
that may be used as a rotation.</p>
|
||
|
|
</div><h2 id='fields' class='fields small-section-header'>
|
||
|
|
Fields<a href='#fields' class='anchor'></a></h2><span id="structfield.coords" class="structfield small-section-header"><a href="#structfield.coords" class="anchor field"></a><code id="coords.v">coords: <a class="type" href="../../nalgebra/base/type.Vector4.html" title="type nalgebra::base::Vector4">Vector4</a><N></code></span><div class='docblock'><p>This quaternion as a 4D vector of coordinates in the <code>[ x, y, z, w ]</code> storage order.</p>
|
||
|
|
</div><h2 id='methods' class='small-section-header'>Methods<a href='#methods' class='anchor'></a></h2><h3 id='impl' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#97-852' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.into_owned' class="method"><code id='into_owned.v'>pub fn <a href='#method.into_owned' class='fnname'>into_owned</a>(self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#101-103' title='goto source code'>[src]</a></h4><div class='stability'><div class='stab deprecated'>Deprecated: <p>This method is a no-op and will be removed in a future release.</p>
|
||
|
|
</div></div><div class='docblock'><p>Moves this unit quaternion into one that owns its data.</p>
|
||
|
|
</div><h4 id='method.clone_owned' class="method"><code id='clone_owned.v'>pub fn <a href='#method.clone_owned' class='fnname'>clone_owned</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#108-110' title='goto source code'>[src]</a></h4><div class='stability'><div class='stab deprecated'>Deprecated: <p>This method is a no-op and will be removed in a future release.</p>
|
||
|
|
</div></div><div class='docblock'><p>Clones this unit quaternion into one that owns its data.</p>
|
||
|
|
</div><h4 id='method.normalize' class="method"><code id='normalize.v'>pub fn <a href='#method.normalize' class='fnname'>normalize</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#123-125' title='goto source code'>[src]</a></h4><div class='docblock'><p>Normalizes this quaternion.</p>
|
||
|
|
<h1 id="example" class="section-header"><a href="#example">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">q_normalized</span> <span class="op">=</span> <span class="ident">q</span>.<span class="ident">normalize</span>();
|
||
|
|
<span class="macro">relative_eq</span><span class="macro">!</span>(<span class="ident">q_normalized</span>.<span class="ident">norm</span>(), <span class="number">1.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.imag' class="method"><code id='imag.v'>pub fn <a href='#method.imag' class='fnname'>imag</a>(&self) -> <a class="type" href="../../nalgebra/base/type.Vector3.html" title="type nalgebra::base::Vector3">Vector3</a><N></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#129-131' title='goto source code'>[src]</a></h4><div class='docblock'><p>The imaginary part of this quaternion.</p>
|
||
|
|
</div><h4 id='method.conjugate' class="method"><code id='conjugate.v'>pub fn <a href='#method.conjugate' class='fnname'>conjugate</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#143-145' title='goto source code'>[src]</a></h4><div class='docblock'><p>The conjugate of this quaternion.</p>
|
||
|
|
<h1 id="example-1" class="section-header"><a href="#example-1">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">conj</span> <span class="op">=</span> <span class="ident">q</span>.<span class="ident">conjugate</span>();
|
||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">conj</span>.<span class="ident">i</span> <span class="op">=</span><span class="op">=</span> <span class="op">-</span><span class="number">2.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">conj</span>.<span class="ident">j</span> <span class="op">=</span><span class="op">=</span> <span class="op">-</span><span class="number">3.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">conj</span>.<span class="ident">k</span> <span class="op">=</span><span class="op">=</span> <span class="op">-</span><span class="number">4.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">conj</span>.<span class="ident">w</span> <span class="op">=</span><span class="op">=</span> <span class="number">1.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.try_inverse' class="method"><code id='try_inverse.v'>pub fn <a href='#method.try_inverse' class='fnname'>try_inverse</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><Self></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#166-174' title='goto source code'>[src]</a></h4><div class='docblock'><p>Inverts this quaternion if it is not zero.</p>
|
||
|
|
<h1 id="example-2" class="section-header"><a href="#example-2">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">inv_q</span> <span class="op">=</span> <span class="ident">q</span>.<span class="ident">try_inverse</span>();
|
||
|
|
|
||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">inv_q</span>.<span class="ident">is_some</span>());
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">inv_q</span>.<span class="ident">unwrap</span>() <span class="op">*</span> <span class="ident">q</span>, <span class="ident">Quaternion</span>::<span class="ident">identity</span>());
|
||
|
|
|
||
|
|
<span class="comment">//Non-invertible case</span>
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">inv_q</span> <span class="op">=</span> <span class="ident">q</span>.<span class="ident">try_inverse</span>();
|
||
|
|
|
||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">inv_q</span>.<span class="ident">is_none</span>());</pre></div>
|
||
|
|
</div><h4 id='method.lerp' class="method"><code id='lerp.v'>pub fn <a href='#method.lerp' class='fnname'>lerp</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self, t: N) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#189-191' title='goto source code'>[src]</a></h4><div class='docblock'><p>Linear interpolation between two quaternion.</p>
|
||
|
|
<p>Computes <code>self * (1 - t) + other * t</code>.</p>
|
||
|
|
<h1 id="example-3" class="section-header"><a href="#example-3">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q1</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">q2</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">10.0</span>, <span class="number">20.0</span>, <span class="number">30.0</span>, <span class="number">40.0</span>);
|
||
|
|
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q1</span>.<span class="ident">lerp</span>(<span class="kw-2">&</span><span class="ident">q2</span>, <span class="number">0.1</span>), <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.9</span>, <span class="number">3.8</span>, <span class="number">5.7</span>, <span class="number">7.6</span>));</pre></div>
|
||
|
|
</div><h4 id='method.vector' class="method"><code id='vector.v'>pub fn <a href='#method.vector' class='fnname'>vector</a>(<br> &self<br>) -> <a class="type" href="../../nalgebra/base/type.MatrixSlice.html" title="type nalgebra::base::MatrixSlice">MatrixSlice</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U3.html" title="struct nalgebra::base::dimension::U3">U3</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>, <a class="type" href="../../nalgebra/base/storage/type.RStride.html" title="type nalgebra::base::storage::RStride">RStride</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, <a class="type" href="../../nalgebra/base/storage/type.CStride.html" title="type nalgebra::base::storage::CStride">CStride</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#204-206' title='goto source code'>[src]</a></h4><div class='docblock'><p>The vector part <code>(i, j, k)</code> of this quaternion.</p>
|
||
|
|
<h1 id="example-4" class="section-header"><a href="#example-4">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">vector</span>()[<span class="number">0</span>], <span class="number">2.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">vector</span>()[<span class="number">1</span>], <span class="number">3.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">vector</span>()[<span class="number">2</span>], <span class="number">4.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.scalar' class="method"><code id='scalar.v'>pub fn <a href='#method.scalar' class='fnname'>scalar</a>(&self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#217-219' title='goto source code'>[src]</a></h4><div class='docblock'><p>The scalar part <code>w</code> of this quaternion.</p>
|
||
|
|
<h1 id="example-5" class="section-header"><a href="#example-5">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">scalar</span>(), <span class="number">1.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.as_vector' class="method"><code id='as_vector.v'>pub fn <a href='#method.as_vector' class='fnname'>as_vector</a>(&self) -> &<a class="type" href="../../nalgebra/base/type.Vector4.html" title="type nalgebra::base::Vector4">Vector4</a><N></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#232-234' title='goto source code'>[src]</a></h4><div class='docblock'><p>Reinterprets this quaternion as a 4D vector.</p>
|
||
|
|
<h1 id="example-6" class="section-header"><a href="#example-6">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="comment">// Recall that the quaternion is stored internally as (i, j, k, w)</span>
|
||
|
|
<span class="comment">// while the crate::new constructor takes the arguments as (w, i, j, k).</span>
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">q</span>.<span class="ident">as_vector</span>(), <span class="ident">Vector4</span>::<span class="ident">new</span>(<span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>, <span class="number">1.0</span>));</pre></div>
|
||
|
|
</div><h4 id='method.norm' class="method"><code id='norm.v'>pub fn <a href='#method.norm' class='fnname'>norm</a>(&self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#246-248' title='goto source code'>[src]</a></h4><div class='docblock'><p>The norm of this quaternion.</p>
|
||
|
|
<h1 id="example-7" class="section-header"><a href="#example-7">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">norm</span>(), <span class="number">5.47722557</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-6</span>);</pre></div>
|
||
|
|
</div><h4 id='method.magnitude' class="method"><code id='magnitude.v'>pub fn <a href='#method.magnitude' class='fnname'>magnitude</a>(&self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#263-265' title='goto source code'>[src]</a></h4><div class='docblock'><p>A synonym for the norm of this quaternion.</p>
|
||
|
|
<p>Aka the length.
|
||
|
|
This is the same as <code>.norm()</code></p>
|
||
|
|
<h1 id="example-8" class="section-header"><a href="#example-8">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">magnitude</span>(), <span class="number">5.47722557</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-6</span>);</pre></div>
|
||
|
|
</div><h4 id='method.norm_squared' class="method"><code id='norm_squared.v'>pub fn <a href='#method.norm_squared' class='fnname'>norm_squared</a>(&self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#276-278' title='goto source code'>[src]</a></h4><div class='docblock'><p>The squared norm of this quaternion.</p>
|
||
|
|
<h1 id="example-9" class="section-header"><a href="#example-9">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">magnitude_squared</span>(), <span class="number">30.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.magnitude_squared' class="method"><code id='magnitude_squared.v'>pub fn <a href='#method.magnitude_squared' class='fnname'>magnitude_squared</a>(&self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#292-294' title='goto source code'>[src]</a></h4><div class='docblock'><p>A synonym for the squared norm of this quaternion.</p>
|
||
|
|
<p>Aka the squared length.
|
||
|
|
This is the same as <code>.norm_squared()</code></p>
|
||
|
|
<h1 id="example-10" class="section-header"><a href="#example-10">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">magnitude_squared</span>(), <span class="number">30.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.dot' class="method"><code id='dot.v'>pub fn <a href='#method.dot' class='fnname'>dot</a>(&self, rhs: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#306-308' title='goto source code'>[src]</a></h4><div class='docblock'><p>The dot product of two quaternions.</p>
|
||
|
|
<h1 id="example-11" class="section-header"><a href="#example-11">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q1</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">q2</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">5.0</span>, <span class="number">6.0</span>, <span class="number">7.0</span>, <span class="number">8.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q1</span>.<span class="ident">dot</span>(<span class="kw-2">&</span><span class="ident">q2</span>), <span class="number">70.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.inner' class="method"><code id='inner.v'>pub fn <a href='#method.inner' class='fnname'>inner</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#324-326' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the inner product (also known as the dot product).
|
||
|
|
See "Foundations of Game Engine Development, Volume 1: Mathematics" by Lengyel
|
||
|
|
Formula 4.89.</p>
|
||
|
|
<h1 id="example-12" class="section-header"><a href="#example-12">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">5.0</span>, <span class="number">2.0</span>, <span class="number">1.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="op">-</span><span class="number">20.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">inner</span>(<span class="kw-2">&</span><span class="ident">b</span>);
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-5</span>);</pre></div>
|
||
|
|
</div><h4 id='method.outer' class="method"><code id='outer.v'>pub fn <a href='#method.outer' class='fnname'>outer</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#343-345' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the outer product (also known as the wedge product).
|
||
|
|
See "Foundations of Game Engine Development, Volume 1: Mathematics" by Lengyel
|
||
|
|
Formula 4.89.</p>
|
||
|
|
<h1 id="example-13" class="section-header"><a href="#example-13">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">5.0</span>, <span class="number">2.0</span>, <span class="number">1.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="op">-</span><span class="number">5.0</span>, <span class="number">18.0</span>, <span class="op">-</span><span class="number">11.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">outer</span>(<span class="kw-2">&</span><span class="ident">b</span>);
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-5</span>);</pre></div>
|
||
|
|
</div><h4 id='method.project' class="method"><code id='project.v'>pub fn <a href='#method.project' class='fnname'>project</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><Self></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#362-364' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the projection of <code>self</code> onto <code>other</code> (also known as the parallel).
|
||
|
|
See "Foundations of Game Engine Development, Volume 1: Mathematics" by Lengyel
|
||
|
|
Formula 4.94.</p>
|
||
|
|
<h1 id="example-14" class="section-header"><a href="#example-14">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">5.0</span>, <span class="number">2.0</span>, <span class="number">1.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">3.333333333333333</span>, <span class="number">1.3333333333333333</span>, <span class="number">0.6666666666666666</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">project</span>(<span class="kw-2">&</span><span class="ident">b</span>).<span class="ident">unwrap</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-5</span>);</pre></div>
|
||
|
|
</div><h4 id='method.reject' class="method"><code id='reject.v'>pub fn <a href='#method.reject' class='fnname'>reject</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><Self></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#381-383' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the rejection of <code>self</code> from <code>other</code> (also known as the perpendicular).
|
||
|
|
See "Foundations of Game Engine Development, Volume 1: Mathematics" by Lengyel
|
||
|
|
Formula 4.94.</p>
|
||
|
|
<h1 id="example-15" class="section-header"><a href="#example-15">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">5.0</span>, <span class="number">2.0</span>, <span class="number">1.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="op">-</span><span class="number">1.3333333333333333</span>, <span class="number">1.6666666666666665</span>, <span class="number">3.3333333333333335</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">reject</span>(<span class="kw-2">&</span><span class="ident">b</span>).<span class="ident">unwrap</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-5</span>);</pre></div>
|
||
|
|
</div><h4 id='method.polar_decomposition' class="method"><code id='polar_decomposition.v'>pub fn <a href='#method.polar_decomposition' class='fnname'>polar_decomposition</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>N, N, <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="../../nalgebra/base/struct.Unit.html" title="struct nalgebra::base::Unit">Unit</a><<a class="type" href="../../nalgebra/base/type.Vector3.html" title="type nalgebra::base::Vector3">Vector3</a><N>>><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#400-412' title='goto source code'>[src]</a></h4><div class='docblock'><p>The polar decomposition of this quaternion.</p>
|
||
|
|
<p>Returns, from left to right: the quaternion norm, the half rotation angle, the rotation
|
||
|
|
axis. If the rotation angle is zero, the rotation axis is set to <code>None</code>.</p>
|
||
|
|
<h1 id="example-16" class="section-header"><a href="#example-16">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">5.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>);
|
||
|
|
<span class="kw">let</span> (<span class="ident">norm</span>, <span class="ident">half_ang</span>, <span class="ident">axis</span>) <span class="op">=</span> <span class="ident">q</span>.<span class="ident">polar_decomposition</span>();
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">norm</span>, <span class="number">5.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">half_ang</span>, <span class="ident">f32</span>::<span class="ident">consts</span>::<span class="ident">FRAC_PI_2</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">axis</span>, <span class="prelude-val">Some</span>(<span class="ident">Vector3</span>::<span class="ident">x_axis</span>()));</pre></div>
|
||
|
|
</div><h4 id='method.ln' class="method"><code id='ln.v'>pub fn <a href='#method.ln' class='fnname'>ln</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#424-430' title='goto source code'>[src]</a></h4><div class='docblock'><p>Compute the natural logarithm of a quaternion.</p>
|
||
|
|
<h1 id="example-17" class="section-header"><a href="#example-17">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">2.0</span>, <span class="number">5.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>);
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">ln</span>(), <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.683647</span>, <span class="number">1.190289</span>, <span class="number">0.0</span>, <span class="number">0.0</span>), <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-6</span>)</pre></div>
|
||
|
|
</div><h4 id='method.exp' class="method"><code id='exp.v'>pub fn <a href='#method.exp' class='fnname'>exp</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#442-444' title='goto source code'>[src]</a></h4><div class='docblock'><p>Compute the exponential of a quaternion.</p>
|
||
|
|
<h1 id="example-18" class="section-header"><a href="#example-18">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.683647</span>, <span class="number">1.190289</span>, <span class="number">0.0</span>, <span class="number">0.0</span>);
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">exp</span>(), <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">2.0</span>, <span class="number">5.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>), <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-5</span>)</pre></div>
|
||
|
|
</div><h4 id='method.exp_eps' class="method"><code id='exp_eps.v'>pub fn <a href='#method.exp_eps' class='fnname'>exp_eps</a>(&self, eps: N) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#461-474' title='goto source code'>[src]</a></h4><div class='docblock'><p>Compute the exponential of a quaternion. Returns the identity if the vector part of this quaternion
|
||
|
|
has a norm smaller than <code>eps</code>.</p>
|
||
|
|
<h1 id="example-19" class="section-header"><a href="#example-19">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.683647</span>, <span class="number">1.190289</span>, <span class="number">0.0</span>, <span class="number">0.0</span>);
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">exp_eps</span>(<span class="number">1.0e-6</span>), <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">2.0</span>, <span class="number">5.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>), <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-5</span>);
|
||
|
|
|
||
|
|
<span class="comment">// Singular case.</span>
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0000001</span>, <span class="number">0.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">exp_eps</span>(<span class="number">1.0e-6</span>), <span class="ident">Quaternion</span>::<span class="ident">identity</span>());</pre></div>
|
||
|
|
</div><h4 id='method.powf' class="method"><code id='powf.v'>pub fn <a href='#method.powf' class='fnname'>powf</a>(&self, n: N) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#486-488' title='goto source code'>[src]</a></h4><div class='docblock'><p>Raise the quaternion to a given floating power.</p>
|
||
|
|
<h1 id="example-20" class="section-header"><a href="#example-20">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">powf</span>(<span class="number">1.5</span>), <span class="ident">Quaternion</span>::<span class="ident">new</span>( <span class="op">-</span><span class="number">6.2576659</span>, <span class="number">4.1549037</span>, <span class="number">6.2323556</span>, <span class="number">8.3098075</span>), <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-6</span>);</pre></div>
|
||
|
|
</div><h4 id='method.as_vector_mut' class="method"><code id='as_vector_mut.v'>pub fn <a href='#method.as_vector_mut' class='fnname'>as_vector_mut</a>(&mut self) -> &mut <a class="type" href="../../nalgebra/base/type.Vector4.html" title="type nalgebra::base::Vector4">Vector4</a><N></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#500-502' title='goto source code'>[src]</a></h4><div class='docblock'><p>Transforms this quaternion into its 4D vector form (Vector part, Scalar part).</p>
|
||
|
|
<h1 id="example-21" class="section-header"><a href="#example-21">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">identity</span>();
|
||
|
|
<span class="kw-2">*</span><span class="ident">q</span>.<span class="ident">as_vector_mut</span>() <span class="op">=</span> <span class="ident">Vector4</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">i</span> <span class="op">=</span><span class="op">=</span> <span class="number">1.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">j</span> <span class="op">=</span><span class="op">=</span> <span class="number">2.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">k</span> <span class="op">=</span><span class="op">=</span> <span class="number">3.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">w</span> <span class="op">=</span><span class="op">=</span> <span class="number">4.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.vector_mut' class="method"><code id='vector_mut.v'>pub fn <a href='#method.vector_mut' class='fnname'>vector_mut</a>(<br> &mut self<br>) -> <a class="type" href="../../nalgebra/base/type.MatrixSliceMut.html" title="type nalgebra::base::MatrixSliceMut">MatrixSliceMut</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U3.html" title="struct nalgebra::base::dimension::U3">U3</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>, <a class="type" href="../../nalgebra/base/storage/type.RStride.html" title="type nalgebra::base::storage::RStride">RStride</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, <a class="type" href="../../nalgebra/base/storage/type.CStride.html" title="type nalgebra::base::storage::CStride">CStride</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#519-523' title='goto source code'>[src]</a></h4><div class='docblock'><p>The mutable vector part <code>(i, j, k)</code> of this quaternion.</p>
|
||
|
|
<h1 id="example-22" class="section-header"><a href="#example-22">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">identity</span>();
|
||
|
|
{
|
||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">q</span>.<span class="ident">vector_mut</span>();
|
||
|
|
<span class="ident">v</span>[<span class="number">0</span>] <span class="op">=</span> <span class="number">2.0</span>;
|
||
|
|
<span class="ident">v</span>[<span class="number">1</span>] <span class="op">=</span> <span class="number">3.0</span>;
|
||
|
|
<span class="ident">v</span>[<span class="number">2</span>] <span class="op">=</span> <span class="number">4.0</span>;
|
||
|
|
}
|
||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">i</span> <span class="op">=</span><span class="op">=</span> <span class="number">2.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">j</span> <span class="op">=</span><span class="op">=</span> <span class="number">3.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">k</span> <span class="op">=</span><span class="op">=</span> <span class="number">4.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">w</span> <span class="op">=</span><span class="op">=</span> <span class="number">1.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.conjugate_mut' class="method"><code id='conjugate_mut.v'>pub fn <a href='#method.conjugate_mut' class='fnname'>conjugate_mut</a>(&mut self)</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#535-539' title='goto source code'>[src]</a></h4><div class='docblock'><p>Replaces this quaternion by its conjugate.</p>
|
||
|
|
<h1 id="example-23" class="section-header"><a href="#example-23">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="ident">q</span>.<span class="ident">conjugate_mut</span>();
|
||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">i</span> <span class="op">=</span><span class="op">=</span> <span class="op">-</span><span class="number">2.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">j</span> <span class="op">=</span><span class="op">=</span> <span class="op">-</span><span class="number">3.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">k</span> <span class="op">=</span><span class="op">=</span> <span class="op">-</span><span class="number">4.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">w</span> <span class="op">=</span><span class="op">=</span> <span class="number">1.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.try_inverse_mut' class="method"><code id='try_inverse_mut.v'>pub fn <a href='#method.try_inverse_mut' class='fnname'>try_inverse_mut</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#557-568' title='goto source code'>[src]</a></h4><div class='docblock'><p>Inverts this quaternion in-place if it is not zero.</p>
|
||
|
|
<h1 id="example-24" class="section-header"><a href="#example-24">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
|
||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">try_inverse_mut</span>());
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">q</span> <span class="op">*</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>), <span class="ident">Quaternion</span>::<span class="ident">identity</span>());
|
||
|
|
|
||
|
|
<span class="comment">//Non-invertible case</span>
|
||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>, <span class="number">0.0</span>);
|
||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">q</span>.<span class="ident">try_inverse_mut</span>());</pre></div>
|
||
|
|
</div><h4 id='method.normalize_mut' class="method"><code id='normalize_mut.v'>pub fn <a href='#method.normalize_mut' class='fnname'>normalize_mut</a>(&mut self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#581-583' title='goto source code'>[src]</a></h4><div class='docblock'><p>Normalizes this quaternion.</p>
|
||
|
|
<h1 id="example-25" class="section-header"><a href="#example-25">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="ident">q</span>.<span class="ident">normalize_mut</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">norm</span>(), <span class="number">1.0</span>);</pre></div>
|
||
|
|
</div><h4 id='method.squared' class="method"><code id='squared.v'>pub fn <a href='#method.squared' class='fnname'>squared</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#587-589' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates square of a quaternion.</p>
|
||
|
|
</div><h4 id='method.half' class="method"><code id='half.v'>pub fn <a href='#method.half' class='fnname'>half</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#593-595' title='goto source code'>[src]</a></h4><div class='docblock'><p>Divides quaternion into two.</p>
|
||
|
|
</div><h4 id='method.sqrt' class="method"><code id='sqrt.v'>pub fn <a href='#method.sqrt' class='fnname'>sqrt</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#599-601' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates square root.</p>
|
||
|
|
</div><h4 id='method.is_pure' class="method"><code id='is_pure.v'>pub fn <a href='#method.is_pure' class='fnname'>is_pure</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#605-607' title='goto source code'>[src]</a></h4><div class='docblock'><p>Check if the quaternion is pure.</p>
|
||
|
|
</div><h4 id='method.pure' class="method"><code id='pure.v'>pub fn <a href='#method.pure' class='fnname'>pure</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#611-613' title='goto source code'>[src]</a></h4><div class='docblock'><p>Convert quaternion to pure quaternion.</p>
|
||
|
|
</div><h4 id='method.left_div' class="method"><code id='left_div.v'>pub fn <a href='#method.left_div' class='fnname'>left_div</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><Self></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#619-621' title='goto source code'>[src]</a></h4><div class='docblock'><p>Left quaternionic division.</p>
|
||
|
|
<p>Calculates B<sup>-1</sup> * A where A = self, B = other.</p>
|
||
|
|
</div><h4 id='method.right_div' class="method"><code id='right_div.v'>pub fn <a href='#method.right_div' class='fnname'>right_div</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><Self></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#638-640' title='goto source code'>[src]</a></h4><div class='docblock'><p>Right quaternionic division.</p>
|
||
|
|
<p>Calculates A * B<sup>-1</sup> where A = self, B = other.</p>
|
||
|
|
<h1 id="example-26" class="section-header"><a href="#example-26">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.0</span>, <span class="number">5.0</span>, <span class="number">2.0</span>, <span class="number">1.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">right_div</span>(<span class="kw-2">&</span><span class="ident">b</span>).<span class="ident">unwrap</span>();
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.4</span>, <span class="number">0.13333333333333336</span>, <span class="op">-</span><span class="number">0.4666666666666667</span>, <span class="number">0.26666666666666666</span>);
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.cos' class="method"><code id='cos.v'>pub fn <a href='#method.cos' class='fnname'>cos</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#654-658' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the quaternionic cosinus.</p>
|
||
|
|
<h1 id="example-27" class="section-header"><a href="#example-27">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">58.93364616794395</span>, <span class="op">-</span><span class="number">34.086183690465596</span>, <span class="op">-</span><span class="number">51.1292755356984</span>, <span class="op">-</span><span class="number">68.17236738093119</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">cos</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.acos' class="method"><code id='acos.v'>pub fn <a href='#method.acos' class='fnname'>acos</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#671-678' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the quaternionic arccosinus.</p>
|
||
|
|
<h1 id="example-28" class="section-header"><a href="#example-28">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">cos</span>().<span class="ident">acos</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">input</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.sin' class="method"><code id='sin.v'>pub fn <a href='#method.sin' class='fnname'>sin</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#692-696' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the quaternionic sinus.</p>
|
||
|
|
<h1 id="example-29" class="section-header"><a href="#example-29">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">91.78371578403467</span>, <span class="number">21.886486853029176</span>, <span class="number">32.82973027954377</span>, <span class="number">43.77297370605835</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">sin</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.asin' class="method"><code id='asin.v'>pub fn <a href='#method.asin' class='fnname'>asin</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#709-716' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the quaternionic arcsinus.</p>
|
||
|
|
<h1 id="example-30" class="section-header"><a href="#example-30">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">sin</span>().<span class="ident">asin</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">input</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.tan' class="method"><code id='tan.v'>pub fn <a href='#method.tan' class='fnname'>tan</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#730-732' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the quaternionic tangent.</p>
|
||
|
|
<h1 id="example-31" class="section-header"><a href="#example-31">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.00003821631725009489</span>, <span class="number">0.3713971716439371</span>, <span class="number">0.5570957574659058</span>, <span class="number">0.7427943432878743</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">tan</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.atan' class="method"><code id='atan.v'>pub fn <a href='#method.atan' class='fnname'>atan</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#745-752' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the quaternionic arctangent.</p>
|
||
|
|
<h1 id="example-32" class="section-header"><a href="#example-32">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">tan</span>().<span class="ident">atan</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">input</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.sinh' class="method"><code id='sinh.v'>pub fn <a href='#method.sinh' class='fnname'>sinh</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#766-768' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the hyperbolic quaternionic sinus.</p>
|
||
|
|
<h1 id="example-33" class="section-header"><a href="#example-33">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.7323376060463428</span>, <span class="op">-</span><span class="number">0.4482074499805421</span>, <span class="op">-</span><span class="number">0.6723111749708133</span>, <span class="op">-</span><span class="number">0.8964148999610843</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">sinh</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.asinh' class="method"><code id='asinh.v'>pub fn <a href='#method.asinh' class='fnname'>asinh</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#782-785' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the hyperbolic quaternionic arcsinus.</p>
|
||
|
|
<h1 id="example-34" class="section-header"><a href="#example-34">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">2.385889902585242</span>, <span class="number">0.514052600662788</span>, <span class="number">0.7710789009941821</span>, <span class="number">1.028105201325576</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">asinh</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.cosh' class="method"><code id='cosh.v'>pub fn <a href='#method.cosh' class='fnname'>cosh</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#799-801' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the hyperbolic quaternionic cosinus.</p>
|
||
|
|
<h1 id="example-35" class="section-header"><a href="#example-35">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.9615851176369566</span>, <span class="op">-</span><span class="number">0.3413521745610167</span>, <span class="op">-</span><span class="number">0.5120282618415251</span>, <span class="op">-</span><span class="number">0.6827043491220334</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">cosh</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.acosh' class="method"><code id='acosh.v'>pub fn <a href='#method.acosh' class='fnname'>acosh</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#815-818' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the hyperbolic quaternionic arccosinus.</p>
|
||
|
|
<h1 id="example-36" class="section-header"><a href="#example-36">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">2.4014472020074007</span>, <span class="number">0.5162761016176176</span>, <span class="number">0.7744141524264264</span>, <span class="number">1.0325522032352352</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">acosh</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.tanh' class="method"><code id='tanh.v'>pub fn <a href='#method.tanh' class='fnname'>tanh</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#832-834' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the hyperbolic quaternionic tangent.</p>
|
||
|
|
<h1 id="example-37" class="section-header"><a href="#example-37">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0248695360556623</span>, <span class="op">-</span><span class="number">0.10229568178876419</span>, <span class="op">-</span><span class="number">0.1534435226831464</span>, <span class="op">-</span><span class="number">0.20459136357752844</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">tanh</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div><h4 id='method.atanh' class="method"><code id='atanh.v'>pub fn <a href='#method.atanh' class='fnname'>atanh</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#848-851' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the hyperbolic quaternionic arctangent.</p>
|
||
|
|
<h1 id="example-38" class="section-header"><a href="#example-38">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">input</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">0.03230293287000163</span>, <span class="number">0.5173453683196951</span>, <span class="number">0.7760180524795426</span>, <span class="number">1.0346907366393903</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">atanh</span>();
|
||
|
|
<span class="macro">assert_relative_eq</span><span class="macro">!</span>(<span class="ident">expected</span>, <span class="ident">result</span>, <span class="ident">epsilon</span> <span class="op">=</span> <span class="number">1.0e-7</span>);</pre></div>
|
||
|
|
</div></div><h3 id='impl-1' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-1' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#20-106' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from_vector' class="method"><code id='from_vector.v'>pub fn <a href='#method.from_vector' class='fnname'>from_vector</a>(vector: <a class="type" href="../../nalgebra/base/type.Vector4.html" title="type nalgebra::base::Vector4">Vector4</a><N>) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#25-27' title='goto source code'>[src]</a></h4><div class='stability'><div class='stab deprecated'>Deprecated: <p>Use <code>::from</code> instead.</p>
|
||
|
|
</div></div><div class='docblock'><p>Creates a quaternion from a 4D vector. The quaternion scalar part corresponds to the <code>w</code>
|
||
|
|
vector component.</p>
|
||
|
|
</div><h4 id='method.new' class="method"><code id='new.v'>pub fn <a href='#method.new' class='fnname'>new</a>(w: N, i: N, j: N, k: N) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#43-45' title='goto source code'>[src]</a></h4><div class='docblock'><p>Creates a new quaternion from its individual components. Note that the arguments order does
|
||
|
|
<strong>not</strong> follow the storage order.</p>
|
||
|
|
<p>The storage order is <code>[ i, j, k, w ]</code> while the arguments for this functions are in the
|
||
|
|
order <code>(w, i, j, k)</code>.</p>
|
||
|
|
<h1 id="example-39" class="section-header"><a href="#example-39">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">i</span> <span class="op">=</span><span class="op">=</span> <span class="number">2.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">j</span> <span class="op">=</span><span class="op">=</span> <span class="number">3.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">k</span> <span class="op">=</span><span class="op">=</span> <span class="number">4.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">w</span> <span class="op">=</span><span class="op">=</span> <span class="number">1.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">q</span>.<span class="ident">as_vector</span>(), <span class="ident">Vector4</span>::<span class="ident">new</span>(<span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>, <span class="number">1.0</span>));</pre></div>
|
||
|
|
</div><h4 id='method.from_imag' class="method"><code id='from_imag.v'>pub fn <a href='#method.from_imag' class='fnname'>from_imag</a>(vector: <a class="type" href="../../nalgebra/base/type.Vector3.html" title="type nalgebra::base::Vector3">Vector3</a><N>) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#49-51' title='goto source code'>[src]</a></h4><div class='docblock'><p>Constructs a pure quaternion.</p>
|
||
|
|
</div><h4 id='method.from_parts' class="method"><code id='from_parts.v'>pub fn <a href='#method.from_parts' class='fnname'>from_parts</a><SB>(scalar: N, vector: <a class="type" href="../../nalgebra/base/type.Vector.html" title="type nalgebra::base::Vector">Vector</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U3.html" title="struct nalgebra::base::dimension::U3">U3</a>, SB>) -> Self <span class="where fmt-newline">where<br> SB: <a class="trait" href="../../nalgebra/base/storage/trait.Storage.html" title="trait nalgebra::base::storage::Storage">Storage</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U3.html" title="struct nalgebra::base::dimension::U3">U3</a>>, </span></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#69-72' title='goto source code'>[src]</a></h4><div class='docblock'><p>Creates a new quaternion from its scalar and vector parts. Note that the arguments order does
|
||
|
|
<strong>not</strong> follow the storage order.</p>
|
||
|
|
<p>The storage order is [ vector, scalar ].</p>
|
||
|
|
<h1 id="example-40" class="section-header"><a href="#example-40">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">w</span> <span class="op">=</span> <span class="number">1.0</span>;
|
||
|
|
<span class="kw">let</span> <span class="ident">ijk</span> <span class="op">=</span> <span class="ident">Vector3</span>::<span class="ident">new</span>(<span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">from_parts</span>(<span class="ident">w</span>, <span class="ident">ijk</span>);
|
||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">q</span>.<span class="ident">i</span> <span class="op">=</span><span class="op">=</span> <span class="number">2.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">j</span> <span class="op">=</span><span class="op">=</span> <span class="number">3.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">k</span> <span class="op">=</span><span class="op">=</span> <span class="number">4.0</span> <span class="kw-2">&</span><span class="op">&</span> <span class="ident">q</span>.<span class="ident">w</span> <span class="op">=</span><span class="op">=</span> <span class="number">1.0</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">q</span>.<span class="ident">as_vector</span>(), <span class="ident">Vector4</span>::<span class="ident">new</span>(<span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>, <span class="number">1.0</span>));</pre></div>
|
||
|
|
</div><h4 id='method.from_real' class="method"><code id='from_real.v'>pub fn <a href='#method.from_real' class='fnname'>from_real</a>(r: N) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#76-78' title='goto source code'>[src]</a></h4><div class='docblock'><p>Constructs a real quaternion.</p>
|
||
|
|
</div><h4 id='method.from_polar_decomposition' class="method"><code id='from_polar_decomposition.v'>pub fn <a href='#method.from_polar_decomposition' class='fnname'>from_polar_decomposition</a><SB>(<br> scale: N, <br> theta: N, <br> axis: <a class="struct" href="../../nalgebra/base/struct.Unit.html" title="struct nalgebra::base::Unit">Unit</a><<a class="type" href="../../nalgebra/base/type.Vector.html" title="type nalgebra::base::Vector">Vector</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U3.html" title="struct nalgebra::base::dimension::U3">U3</a>, SB>><br>) -> Self <span class="where fmt-newline">where<br> SB: <a class="trait" href="../../nalgebra/base/storage/trait.Storage.html" title="trait nalgebra::base::storage::Storage">Storage</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U3.html" title="struct nalgebra::base::dimension::U3">U3</a>>, </span></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#84-89' title='goto source code'>[src]</a></h4><div class='docblock'><p>Creates a new quaternion from its polar decomposition.</p>
|
||
|
|
<p>Note that <code>axis</code> is assumed to be a unit vector.</p>
|
||
|
|
</div><h4 id='method.identity' class="method"><code id='identity.v'>pub fn <a href='#method.identity' class='fnname'>identity</a>() -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#103-105' title='goto source code'>[src]</a></h4><div class='docblock'><p>The quaternion multiplicative identity.</p>
|
||
|
|
<h1 id="example-41" class="section-header"><a href="#example-41">Example</a></h1>
|
||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
|
|
<span class="kw">let</span> <span class="ident">q</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">identity</span>();
|
||
|
|
<span class="kw">let</span> <span class="ident">q2</span> <span class="op">=</span> <span class="ident">Quaternion</span>::<span class="ident">new</span>(<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>, <span class="number">4.0</span>);
|
||
|
|
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q</span> <span class="op">*</span> <span class="ident">q2</span>, <span class="ident">q2</span>);
|
||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">q2</span> <span class="op">*</span> <span class="ident">q</span>, <span class="ident">q2</span>);</pre></div>
|
||
|
|
</div></div><h2 id='implementations' class='small-section-header'>Trait Implementations<a href='#implementations' class='anchor'></a></h2><div id='implementations-list'><h3 id='impl-Eq' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Eq' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#50' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-Clone' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Clone' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#68-73' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.clone' class="method hidden"><code id='clone.v'>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#70-72' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone">Read more</a></p>
|
||
|
|
</div><h4 id='method.clone_from' class="method hidden"><code id='clone_from.v'>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&mut self, source: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self)</code><span class='since' title='Stable since Rust version 1.0.0'>1.0.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/clone.rs.html#131-133' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-PartialEq%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-PartialEq%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#52-58' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.eq' class="method hidden"><code id='eq.v'>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, rhs: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#53-57' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq">Read more</a></p>
|
||
|
|
</div><h4 id='method.ne' class="method hidden"><code id='ne.v'><span class="docblock attributes">#[must_use]
|
||
|
|
</span>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><span class='since' title='Stable since Rust version 1.0.0'>1.0.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#208' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>!=</code>.</p>
|
||
|
|
</div></div><h3 id='impl-From%3CMatrix%3CN%2C%20U4%2C%20U1%2C%20%3CDefaultAllocator%20as%20Allocator%3CN%2C%20U4%2C%20U1%3E%3E%3A%3ABuffer%3E%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="../../nalgebra/base/struct.Matrix.html" title="struct nalgebra::base::Matrix">Matrix</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>, <<a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a> as <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>>::<a class="type" href="../../nalgebra/base/allocator/trait.Allocator.html#associatedtype.Buffer" title="type nalgebra::base::allocator::Allocator::Buffer">Buffer</a>>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-From%3CMatrix%3CN%2C%20U4%2C%20U1%2C%20%3CDefaultAllocator%20as%20Allocator%3CN%2C%20U4%2C%20U1%3E%3E%3A%3ABuffer%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_conversion.rs.html#249-254' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from' class="method hidden"><code id='from.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(coords: <a class="type" href="../../nalgebra/base/type.Vector4.html" title="type nalgebra::base::Vector4">Vector4</a><N>) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_conversion.rs.html#251-253' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
|
||
|
|
</div></div><h3 id='impl-Copy' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Copy' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#66' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-DerefMut' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/deref/trait.DerefMut.html" title="trait core::ops::deref::DerefMut">DerefMut</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-DerefMut' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_coordinates.rs.html#19-24' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.deref_mut' class="method hidden"><code id='deref_mut.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/deref/trait.DerefMut.html#tymethod.deref_mut' class='fnname'>deref_mut</a>(&mut self) -> &mut Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#associatedtype.Target" title="type core::ops::deref::Deref::Target">Target</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_coordinates.rs.html#21-23' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Mutably dereferences the value.</p>
|
||
|
|
</div></div><h3 id='impl-Hash' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Hash' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#60-64' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.hash' class="method hidden"><code id='hash.v'>fn <a href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash' class='fnname'>hash</a><H: <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>>(&self, state: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>H)</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#61-63' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Feeds this value into the given [<code>Hasher</code>]. <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash">Read more</a></p>
|
||
|
|
</div><h4 id='method.hash_slice' class="method hidden"><code id='hash_slice.v'>fn <a href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice' class='fnname'>hash_slice</a><H>(data: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[Self]</a>, state: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>H) <span class="where fmt-newline">where<br> H: <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>, </span></code><span class='since' title='Stable since Rust version 1.3.0'>1.3.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#192-198' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Feeds a slice of this type into the given [<code>Hasher</code>]. <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-Add%3C%26%27b%20Quaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<'a, 'b, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for &'a <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Add%3C%26%27b%20Quaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output' class="type"><code id='Output.t'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
|
||
|
|
</div><h4 id='method.add' class="method hidden"><code id='add.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#tymethod.add' class='fnname'>add</a>(self, rhs: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#associatedtype.Output" title="type core::ops::arith::Add::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>+</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Add%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<'a, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for &'a <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Add%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-1' class="type"><code id='Output.t-1'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
|
||
|
|
</div><h4 id='method.add-1' class="method hidden"><code id='add.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#tymethod.add' class='fnname'>add</a>(self, rhs: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#associatedtype.Output" title="type core::ops::arith::Add::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>+</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Add%3C%26%27b%20Quaternion%3CN%3E%3E-1' class='impl'><code class='in-band'>impl<'b, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Add%3C%26%27b%20Quaternion%3CN%3E%3E-1' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-2' class="type"><code id='Output.t-2'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
|
||
|
|
</div><h4 id='method.add-2' class="method hidden"><code id='add.v-2'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#tymethod.add' class='fnname'>add</a>(self, rhs: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#associatedtype.Output" title="type core::ops::arith::Add::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>+</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Add%3CQuaternion%3CN%3E%3E-1' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Add%3CQuaternion%3CN%3E%3E-1' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-3' class="type"><code id='Output.t-3'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>+</code> operator.</p>
|
||
|
|
</div><h4 id='method.add-3' class="method hidden"><code id='add.v-3'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#tymethod.add' class='fnname'>add</a>(self, rhs: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html#associatedtype.Output" title="type core::ops::arith::Add::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>+</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Sub%3C%26%27b%20Quaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<'a, 'b, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for &'a <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Sub%3C%26%27b%20Quaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-4' class="type"><code id='Output.t-4'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
|
||
|
|
</div><h4 id='method.sub' class="method hidden"><code id='sub.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#tymethod.sub' class='fnname'>sub</a>(self, rhs: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#associatedtype.Output" title="type core::ops::arith::Sub::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>-</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Sub%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<'a, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for &'a <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Sub%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-5' class="type"><code id='Output.t-5'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
|
||
|
|
</div><h4 id='method.sub-1' class="method hidden"><code id='sub.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#tymethod.sub' class='fnname'>sub</a>(self, rhs: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#associatedtype.Output" title="type core::ops::arith::Sub::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>-</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Sub%3C%26%27b%20Quaternion%3CN%3E%3E-1' class='impl'><code class='in-band'>impl<'b, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Sub%3C%26%27b%20Quaternion%3CN%3E%3E-1' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-6' class="type"><code id='Output.t-6'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
|
||
|
|
</div><h4 id='method.sub-2' class="method hidden"><code id='sub.v-2'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#tymethod.sub' class='fnname'>sub</a>(self, rhs: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#associatedtype.Output" title="type core::ops::arith::Sub::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>-</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Sub%3CQuaternion%3CN%3E%3E-1' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Sub%3CQuaternion%3CN%3E%3E-1' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-7' class="type"><code id='Output.t-7'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
|
||
|
|
</div><h4 id='method.sub-3' class="method hidden"><code id='sub.v-3'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#tymethod.sub' class='fnname'>sub</a>(self, rhs: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html#associatedtype.Output" title="type core::ops::arith::Sub::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>-</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Mul%3C%26%27b%20Quaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<'a, 'b, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for &'a <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Mul%3C%26%27b%20Quaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-8' class="type"><code id='Output.t-8'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
|
||
|
|
</div><h4 id='method.mul' class="method hidden"><code id='mul.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, rhs: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output" title="type core::ops::arith::Mul::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Mul%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<'a, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for &'a <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Mul%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-9' class="type"><code id='Output.t-9'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
|
||
|
|
</div><h4 id='method.mul-1' class="method hidden"><code id='mul.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, rhs: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output" title="type core::ops::arith::Mul::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Mul%3C%26%27b%20Quaternion%3CN%3E%3E-1' class='impl'><code class='in-band'>impl<'b, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Mul%3C%26%27b%20Quaternion%3CN%3E%3E-1' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-10' class="type"><code id='Output.t-10'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
|
||
|
|
</div><h4 id='method.mul-2' class="method hidden"><code id='mul.v-2'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, rhs: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output" title="type core::ops::arith::Mul::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Mul%3CQuaternion%3CN%3E%3E-1' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-Mul%3CQuaternion%3CN%3E%3E-1' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#88-97' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-11' class="type"><code id='Output.t-11'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
|
||
|
|
</div><h4 id='method.mul-3' class="method hidden"><code id='mul.v-3'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, rhs: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output" title="type core::ops::arith::Mul::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Mul%3CN%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><N> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Mul%3CN%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#493-500' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-12' class="type"><code id='Output.t-12'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
|
||
|
|
</div><h4 id='method.mul-4' class="method hidden"><code id='mul.v-4'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, n: N) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output" title="type core::ops::arith::Mul::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#497-499' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Mul%3CN%3E-1' class='impl'><code class='in-band'>impl<'a, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><N> for &'a <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Mul%3CN%3E-1' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#502-509' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-13' class="type"><code id='Output.t-13'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
|
||
|
|
</div><h4 id='method.mul-5' class="method hidden"><code id='mul.v-5'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, n: N) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output" title="type core::ops::arith::Mul::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#506-508' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Mul%3CQuaternion%3Cf32%3E%3E' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>>> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a></code><a href='#impl-Mul%3CQuaternion%3Cf32%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#528-535' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-14' class="type"><code id='Output.t-14'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>></code></h4><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
|
||
|
|
</div><h4 id='method.mul-6' class="method hidden"><code id='mul.v-6'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, right: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output" title="type core::ops::arith::Mul::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#532-534' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Mul%3C%26%27b%20Quaternion%3Cf32%3E%3E' class='impl'><code class='in-band'>impl<'b> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>>> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a></code><a href='#impl-Mul%3C%26%27b%20Quaternion%3Cf32%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#537-544' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-15' class="type"><code id='Output.t-15'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>></code></h4><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
|
||
|
|
</div><h4 id='method.mul-7' class="method hidden"><code id='mul.v-7'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, right: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output" title="type core::ops::arith::Mul::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#541-543' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Mul%3CQuaternion%3Cf64%3E%3E' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>>> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a></code><a href='#impl-Mul%3CQuaternion%3Cf64%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#528-535' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-16' class="type"><code id='Output.t-16'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>></code></h4><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
|
||
|
|
</div><h4 id='method.mul-8' class="method hidden"><code id='mul.v-8'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, right: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output" title="type core::ops::arith::Mul::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#532-534' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Mul%3C%26%27b%20Quaternion%3Cf64%3E%3E' class='impl'><code class='in-band'>impl<'b> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>>> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a></code><a href='#impl-Mul%3C%26%27b%20Quaternion%3Cf64%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#537-544' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-17' class="type"><code id='Output.t-17'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>></code></h4><div class='docblock'><p>The resulting type after applying the <code>*</code> operator.</p>
|
||
|
|
</div><h4 id='method.mul-9' class="method hidden"><code id='mul.v-9'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, right: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>>) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html#associatedtype.Output" title="type core::ops::arith::Mul::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#541-543' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Div%3CN%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><N> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Div%3CN%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#493-500' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-18' class="type"><code id='Output.t-18'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Div.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
|
||
|
|
</div><h4 id='method.div' class="method hidden"><code id='div.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Div.html#tymethod.div' class='fnname'>div</a>(self, n: N) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Div.html#associatedtype.Output" title="type core::ops::arith::Div::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#497-499' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>/</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Div%3CN%3E-1' class='impl'><code class='in-band'>impl<'a, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><N> for &'a <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Div%3CN%3E-1' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#502-509' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-19' class="type"><code id='Output.t-19'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Div.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>/</code> operator.</p>
|
||
|
|
</div><h4 id='method.div-1' class="method hidden"><code id='div.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Div.html#tymethod.div' class='fnname'>div</a>(self, n: N) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Div.html#associatedtype.Output" title="type core::ops::arith::Div::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#506-508' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>/</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Neg' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Neg.html" title="trait core::ops::arith::Neg">Neg</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Neg' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#550-557' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-20' class="type"><code id='Output.t-20'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Neg.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
|
||
|
|
</div><h4 id='method.neg' class="method hidden"><code id='neg.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Neg.html#tymethod.neg' class='fnname'>neg</a>(self) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Neg.html#associatedtype.Output" title="type core::ops::arith::Neg::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#554-556' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the unary <code>-</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Neg-1' class='impl'><code class='in-band'>impl<'a, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Neg.html" title="trait core::ops::arith::Neg">Neg</a> for &'a <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Neg-1' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#559-566' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-21' class="type"><code id='Output.t-21'>type <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Neg.html#associatedtype.Output' class="type">Output</a> = <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code></h4><div class='docblock'><p>The resulting type after applying the <code>-</code> operator.</p>
|
||
|
|
</div><h4 id='method.neg-1' class="method hidden"><code id='neg.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.Neg.html#tymethod.neg' class='fnname'>neg</a>(self) -> Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Neg.html#associatedtype.Output" title="type core::ops::arith::Neg::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#563-565' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the unary <code>-</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-AddAssign%3C%26%27b%20Quaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<'b, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.AddAssign.html" title="trait core::ops::arith::AddAssign">AddAssign</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-AddAssign%3C%26%27b%20Quaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#573-581' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.add_assign' class="method hidden"><code id='add_assign.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.AddAssign.html#tymethod.add_assign' class='fnname'>add_assign</a>(&mut self, rhs: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>)</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#578-580' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>+=</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-AddAssign%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.AddAssign.html" title="trait core::ops::arith::AddAssign">AddAssign</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-AddAssign%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#573-581' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.add_assign-1' class="method hidden"><code id='add_assign.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.AddAssign.html#tymethod.add_assign' class='fnname'>add_assign</a>(&mut self, rhs: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>)</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#578-580' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>+=</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-SubAssign%3C%26%27b%20Quaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<'b, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.SubAssign.html" title="trait core::ops::arith::SubAssign">SubAssign</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-SubAssign%3C%26%27b%20Quaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#573-581' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.sub_assign' class="method hidden"><code id='sub_assign.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.SubAssign.html#tymethod.sub_assign' class='fnname'>sub_assign</a>(&mut self, rhs: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>)</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#578-580' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>-=</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-SubAssign%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.SubAssign.html" title="trait core::ops::arith::SubAssign">SubAssign</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-SubAssign%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#573-581' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.sub_assign-1' class="method hidden"><code id='sub_assign.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.SubAssign.html#tymethod.sub_assign' class='fnname'>sub_assign</a>(&mut self, rhs: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>)</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#578-580' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>-=</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-MulAssign%3CN%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.MulAssign.html" title="trait core::ops::arith::MulAssign">MulAssign</a><N> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-MulAssign%3CN%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#511-517' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.mul_assign' class="method hidden"><code id='mul_assign.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.MulAssign.html#tymethod.mul_assign' class='fnname'>mul_assign</a>(&mut self, n: N)</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#514-516' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*=</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-MulAssign%3C%26%27b%20Quaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<'b, N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.MulAssign.html" title="trait core::ops::arith::MulAssign">MulAssign</a><&'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-MulAssign%3C%26%27b%20Quaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#573-581' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.mul_assign-1' class="method hidden"><code id='mul_assign.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.MulAssign.html#tymethod.mul_assign' class='fnname'>mul_assign</a>(&mut self, rhs: &'b <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>)</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#578-580' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*=</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-MulAssign%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.MulAssign.html" title="trait core::ops::arith::MulAssign">MulAssign</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> <a class="struct" href="../../nalgebra/base/default_allocator/struct.DefaultAllocator.html" title="struct nalgebra::base::default_allocator::DefaultAllocator">DefaultAllocator</a>: <a class="trait" href="../../nalgebra/base/allocator/trait.Allocator.html" title="trait nalgebra::base::allocator::Allocator">Allocator</a><N, <a class="struct" href="../../nalgebra/base/dimension/struct.U4.html" title="struct nalgebra::base::dimension::U4">U4</a>, <a class="struct" href="../../nalgebra/base/dimension/struct.U1.html" title="struct nalgebra::base::dimension::U1">U1</a>>, </span></code><a href='#impl-MulAssign%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#573-581' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.mul_assign-2' class="method hidden"><code id='mul_assign.v-2'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.MulAssign.html#tymethod.mul_assign' class='fnname'>mul_assign</a>(&mut self, rhs: <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>)</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#578-580' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>*=</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-DivAssign%3CN%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.DivAssign.html" title="trait core::ops::arith::DivAssign">DivAssign</a><N> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-DivAssign%3CN%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#511-517' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.div_assign' class="method hidden"><code id='div_assign.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/arith/trait.DivAssign.html#tymethod.div_assign' class='fnname'>div_assign</a>(&mut self, n: N)</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#514-516' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the <code>/=</code> operation.</p>
|
||
|
|
</div></div><h3 id='impl-Deref' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html" title="trait core::ops::deref::Deref">Deref</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Deref' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_coordinates.rs.html#10-17' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Target' class="type"><code id='Target.t'>type <a href='https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#associatedtype.Target' class="type">Target</a> = <a class="struct" href="../../nalgebra/base/coordinates/struct.IJKW.html" title="struct nalgebra::base::coordinates::IJKW">IJKW</a><N></code></h4><div class='docblock'><p>The resulting type after dereferencing.</p>
|
||
|
|
</div><h4 id='method.deref' class="method hidden"><code id='deref.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#tymethod.deref' class='fnname'>deref</a>(&self) -> &Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#associatedtype.Target" title="type core::ops::deref::Deref::Target">Target</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_coordinates.rs.html#14-16' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Dereferences the value.</p>
|
||
|
|
</div></div><h3 id='impl-Index%3Cusize%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html" title="trait core::ops::index::Index">Index</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Index%3Cusize%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#66-73' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-22' class="type"><code id='Output.t-22'>type <a href='https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#associatedtype.Output' class="type">Output</a> = N</code></h4><div class='docblock'><p>The returned type after indexing.</p>
|
||
|
|
</div><h4 id='method.index' class="method hidden"><code id='index.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#tymethod.index' class='fnname'>index</a>(&self, i: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> &Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#associatedtype.Output" title="type core::ops::index::Index::Output">Output</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#70-72' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the indexing (<code>container[index]</code>) operation.</p>
|
||
|
|
</div></div><h3 id='impl-IndexMut%3Cusize%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/index/trait.IndexMut.html" title="trait core::ops::index::IndexMut">IndexMut</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-IndexMut%3Cusize%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#75-80' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.index_mut' class="method hidden"><code id='index_mut.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/index/trait.IndexMut.html#tymethod.index_mut' class='fnname'>index_mut</a>(&mut self, i: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_ops.rs.html#77-79' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the mutable indexing (<code>container[index]</code>) operation.</p>
|
||
|
|
</div></div><h3 id='impl-Debug' class='impl'><code class='in-band'>impl<N: <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> + <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Debug' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#27' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.fmt' class="method hidden"><code id='fmt.v'>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#27' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-Display' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html" title="trait core::fmt::Display">Display</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html" title="trait core::fmt::Display">Display</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Display' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#904-912' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.fmt-1' class="method hidden"><code id='fmt.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#905-911' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-AbsDiffEq%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a> + <a class="trait" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html" title="trait approx::abs_diff_eq::AbsDiffEq">AbsDiffEq</a><Epsilon = N>> <a class="trait" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html" title="trait approx::abs_diff_eq::AbsDiffEq">AbsDiffEq</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbsDiffEq%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#854-868' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Epsilon' class="type"><code id='Epsilon.t'>type <a href='../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon' class="type">Epsilon</a> = N</code></h4><div class='docblock'><p>Used for specifying relative comparisons.</p>
|
||
|
|
</div><h4 id='method.default_epsilon' class="method hidden"><code id='default_epsilon.v'>fn <a href='../../approx/abs_diff_eq/trait.AbsDiffEq.html#tymethod.default_epsilon' class='fnname'>default_epsilon</a>() -> Self::<a class="type" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon" title="type approx::abs_diff_eq::AbsDiffEq::Epsilon">Epsilon</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#858-860' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The default tolerance to use when testing values that are close together. <a href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#tymethod.default_epsilon">Read more</a></p>
|
||
|
|
</div><h4 id='method.abs_diff_eq' class="method hidden"><code id='abs_diff_eq.v'>fn <a href='../../approx/abs_diff_eq/trait.AbsDiffEq.html#tymethod.abs_diff_eq' class='fnname'>abs_diff_eq</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self, epsilon: Self::<a class="type" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon" title="type approx::abs_diff_eq::AbsDiffEq::Epsilon">Epsilon</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#863-867' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>A test for equality that uses the absolute difference to compute the approximate equality of two numbers. <a href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#tymethod.abs_diff_eq">Read more</a></p>
|
||
|
|
</div><h4 id='method.abs_diff_ne' class="method hidden"><code id='abs_diff_ne.v'>fn <a href='../../approx/abs_diff_eq/trait.AbsDiffEq.html#method.abs_diff_ne' class='fnname'>abs_diff_ne</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Rhs, epsilon: Self::<a class="type" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon" title="type approx::abs_diff_eq::AbsDiffEq::Epsilon">Epsilon</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/approx/abs_diff_eq.rs.html#26-28' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The inverse of <code>ApproxEq::abs_diff_eq</code>.</p>
|
||
|
|
</div></div><h3 id='impl-RelativeEq%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a> + <a class="trait" href="../../approx/relative_eq/trait.RelativeEq.html" title="trait approx::relative_eq::RelativeEq">RelativeEq</a><Epsilon = N>> <a class="trait" href="../../approx/relative_eq/trait.RelativeEq.html" title="trait approx::relative_eq::RelativeEq">RelativeEq</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-RelativeEq%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#870-888' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.default_max_relative' class="method hidden"><code id='default_max_relative.v'>fn <a href='../../approx/relative_eq/trait.RelativeEq.html#tymethod.default_max_relative' class='fnname'>default_max_relative</a>() -> Self::<a class="type" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon" title="type approx::abs_diff_eq::AbsDiffEq::Epsilon">Epsilon</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#872-874' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The default relative tolerance for testing values that are far-apart. <a href="../../approx/relative_eq/trait.RelativeEq.html#tymethod.default_max_relative">Read more</a></p>
|
||
|
|
</div><h4 id='method.relative_eq' class="method hidden"><code id='relative_eq.v'>fn <a href='../../approx/relative_eq/trait.RelativeEq.html#tymethod.relative_eq' class='fnname'>relative_eq</a>(<br> &self, <br> other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self, <br> epsilon: Self::<a class="type" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon" title="type approx::abs_diff_eq::AbsDiffEq::Epsilon">Epsilon</a>, <br> max_relative: Self::<a class="type" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon" title="type approx::abs_diff_eq::AbsDiffEq::Epsilon">Epsilon</a><br>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#877-887' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>A test for equality that uses a relative comparison if the values are far apart.</p>
|
||
|
|
</div><h4 id='method.relative_ne' class="method hidden"><code id='relative_ne.v'>fn <a href='../../approx/relative_eq/trait.RelativeEq.html#method.relative_ne' class='fnname'>relative_ne</a>(<br> &self, <br> other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Rhs, <br> epsilon: Self::<a class="type" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon" title="type approx::abs_diff_eq::AbsDiffEq::Epsilon">Epsilon</a>, <br> max_relative: Self::<a class="type" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon" title="type approx::abs_diff_eq::AbsDiffEq::Epsilon">Epsilon</a><br>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/approx/relative_eq.rs.html#29-36' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The inverse of <code>ApproxEq::relative_eq</code>.</p>
|
||
|
|
</div></div><h3 id='impl-UlpsEq%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a> + <a class="trait" href="../../approx/ulps_eq/trait.UlpsEq.html" title="trait approx::ulps_eq::UlpsEq">UlpsEq</a><Epsilon = N>> <a class="trait" href="../../approx/ulps_eq/trait.UlpsEq.html" title="trait approx::ulps_eq::UlpsEq">UlpsEq</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-UlpsEq%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#890-902' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.default_max_ulps' class="method hidden"><code id='default_max_ulps.v'>fn <a href='../../approx/ulps_eq/trait.UlpsEq.html#tymethod.default_max_ulps' class='fnname'>default_max_ulps</a>() -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#892-894' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The default ULPs to tolerate when testing values that are far-apart. <a href="../../approx/ulps_eq/trait.UlpsEq.html#tymethod.default_max_ulps">Read more</a></p>
|
||
|
|
</div><h4 id='method.ulps_eq' class="method hidden"><code id='ulps_eq.v'>fn <a href='../../approx/ulps_eq/trait.UlpsEq.html#tymethod.ulps_eq' class='fnname'>ulps_eq</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self, epsilon: Self::<a class="type" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon" title="type approx::abs_diff_eq::AbsDiffEq::Epsilon">Epsilon</a>, max_ulps: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion.rs.html#897-901' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>A test for equality that uses units in the last place (ULP) if the values are far apart.</p>
|
||
|
|
</div><h4 id='method.ulps_ne' class="method hidden"><code id='ulps_ne.v'>fn <a href='../../approx/ulps_eq/trait.UlpsEq.html#method.ulps_ne' class='fnname'>ulps_ne</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Rhs, epsilon: Self::<a class="type" href="../../approx/abs_diff_eq/trait.AbsDiffEq.html#associatedtype.Epsilon" title="type approx::abs_diff_eq::AbsDiffEq::Epsilon">Epsilon</a>, max_ulps: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/approx/ulps_eq.rs.html#24-26' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The inverse of <code>ApproxEq::ulps_eq</code>.</p>
|
||
|
|
</div></div><h3 id='impl-Zero' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../num_traits/identities/trait.Zero.html" title="trait num_traits::identities::Zero">Zero</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Zero' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#115-125' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.zero' class="method hidden"><code id='zero.v'>fn <a href='../../num_traits/identities/trait.Zero.html#tymethod.zero' class='fnname'>zero</a>() -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#117-119' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns the additive identity element of <code>Self</code>, <code>0</code>. # Purity <a href="../../num_traits/identities/trait.Zero.html#tymethod.zero">Read more</a></p>
|
||
|
|
</div><h4 id='method.is_zero' class="method hidden"><code id='is_zero.v'>fn <a href='../../num_traits/identities/trait.Zero.html#tymethod.is_zero' class='fnname'>is_zero</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#122-124' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns <code>true</code> if <code>self</code> is equal to the additive identity.</p>
|
||
|
|
</div><h4 id='method.set_zero' class="method hidden"><code id='set_zero.v'>fn <a href='../../num_traits/identities/trait.Zero.html#method.set_zero' class='fnname'>set_zero</a>(&mut self)</code><a class='srclink' href='../../src/num_traits/identities.rs.html#23-25' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Sets <code>self</code> to the additive identity element of <code>Self</code>, <code>0</code>.</p>
|
||
|
|
</div></div><h3 id='impl-One' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../num_traits/identities/trait.One.html" title="trait num_traits::identities::One">One</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-One' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#108-113' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.one' class="method hidden"><code id='one.v'>fn <a href='../../num_traits/identities/trait.One.html#tymethod.one' class='fnname'>one</a>() -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#110-112' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns the multiplicative identity element of <code>Self</code>, <code>1</code>. <a href="../../num_traits/identities/trait.One.html#tymethod.one">Read more</a></p>
|
||
|
|
</div><h4 id='method.set_one' class="method hidden"><code id='set_one.v'>fn <a href='../../num_traits/identities/trait.One.html#method.set_one' class='fnname'>set_one</a>(&mut self)</code><a class='srclink' href='../../src/num_traits/identities.rs.html#103-105' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Sets <code>self</code> to the multiplicative identity element of <code>Self</code>, <code>1</code>.</p>
|
||
|
|
</div><h4 id='method.is_one' class="method hidden"><code id='is_one.v'>fn <a href='../../num_traits/identities/trait.One.html#method.is_one' class='fnname'>is_one</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a><Self>, </span></code><a class='srclink' href='../../src/num_traits/identities.rs.html#113-118' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns <code>true</code> if <code>self</code> is equal to the multiplicative identity. <a href="../../num_traits/identities/trait.One.html#method.is_one">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-Distribution%3CQuaternion%3CN%3E%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../rand/distributions/trait.Distribution.html" title="trait rand::distributions::Distribution">Distribution</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N>> for <a class="struct" href="../../rand/distributions/struct.Standard.html" title="struct rand::distributions::Standard">Standard</a> <span class="where fmt-newline">where<br> <a class="struct" href="../../rand/distributions/struct.Standard.html" title="struct rand::distributions::Standard">Standard</a>: <a class="trait" href="../../rand/distributions/trait.Distribution.html" title="trait rand::distributions::Distribution">Distribution</a><N>, </span></code><a href='#impl-Distribution%3CQuaternion%3CN%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#127-134' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.sample' class="method hidden"><code id='sample.v'>fn <a href='../../rand/distributions/trait.Distribution.html#tymethod.sample' class='fnname'>sample</a><'a, R: <a class="trait" href="../../rand/trait.Rng.html" title="trait rand::Rng">Rng</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>>(&self, rng: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R) -> <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_construction.rs.html#131-133' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Generate a random value of <code>T</code>, using <code>rng</code> as the source of randomness.</p>
|
||
|
|
</div><h4 id='method.sample_iter' class="method hidden"><code id='sample_iter.v'>fn <a href='../../rand/distributions/trait.Distribution.html#method.sample_iter' class='fnname'>sample_iter</a><R>(&'a self, rng: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R) -> <a class="struct" href="../../rand/distributions/struct.DistIter.html" title="struct rand::distributions::DistIter">DistIter</a><'a, Self, R, T> <span class="where fmt-newline">where<br> R: <a class="trait" href="../../rand/trait.Rng.html" title="trait rand::Rng">Rng</a>, </span></code><a class='srclink' href='../../src/rand/distributions/mod.rs.html#261-269' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Create an iterator that generates random values of <code>T</code>, using <code>rng</code> as the source of randomness. <a href="../../rand/distributions/trait.Distribution.html#method.sample_iter">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-AbstractMagma%3CMultiplicative%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/one_operator/trait.AbstractMagma.html" title="trait alga::general::one_operator::AbstractMagma">AbstractMagma</a><<a class="struct" href="../../alga/general/operator/struct.Multiplicative.html" title="struct alga::general::operator::Multiplicative">Multiplicative</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractMagma%3CMultiplicative%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#31-36' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.operate' class="method hidden"><code id='operate.v'>fn <a href='../../alga/general/one_operator/trait.AbstractMagma.html#tymethod.operate' class='fnname'>operate</a>(&self, rhs: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#33-35' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs an operation.</p>
|
||
|
|
</div><h4 id='method.op' class="method hidden"><code id='op.v'>fn <a href='../../alga/general/one_operator/trait.AbstractMagma.html#method.op' class='fnname'>op</a>(&self, O, lhs: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> Self</code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#25-27' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs specific operation.</p>
|
||
|
|
</div></div><h3 id='impl-AbstractMagma%3CAdditive%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/one_operator/trait.AbstractMagma.html" title="trait alga::general::one_operator::AbstractMagma">AbstractMagma</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractMagma%3CAdditive%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#38-43' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.operate-1' class="method hidden"><code id='operate.v-1'>fn <a href='../../alga/general/one_operator/trait.AbstractMagma.html#tymethod.operate' class='fnname'>operate</a>(&self, rhs: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#40-42' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs an operation.</p>
|
||
|
|
</div><h4 id='method.op-1' class="method hidden"><code id='op.v-1'>fn <a href='../../alga/general/one_operator/trait.AbstractMagma.html#method.op' class='fnname'>op</a>(&self, O, lhs: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> Self</code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#25-27' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs specific operation.</p>
|
||
|
|
</div></div><h3 id='impl-AbstractQuasigroup%3CAdditive%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/one_operator/trait.AbstractQuasigroup.html" title="trait alga::general::one_operator::AbstractQuasigroup">AbstractQuasigroup</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractQuasigroup%3CAdditive%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#54' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.prop_inv_is_latin_square_approx' class="method hidden"><code id='prop_inv_is_latin_square_approx.v'>fn <a href='../../alga/general/one_operator/trait.AbstractQuasigroup.html#method.prop_inv_is_latin_square_approx' class='fnname'>prop_inv_is_latin_square_approx</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self, Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="../../approx/relative_eq/trait.RelativeEq.html" title="trait approx::relative_eq::RelativeEq">RelativeEq</a><Self>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#57-66' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns <code>true</code> if latin squareness holds for the given arguments. Approximate equality is used for verifications. <a href="../../alga/general/one_operator/trait.AbstractQuasigroup.html#method.prop_inv_is_latin_square_approx">Read more</a></p>
|
||
|
|
</div><h4 id='method.prop_inv_is_latin_square' class="method hidden"><code id='prop_inv_is_latin_square.v'>fn <a href='../../alga/general/one_operator/trait.AbstractQuasigroup.html#method.prop_inv_is_latin_square' class='fnname'>prop_inv_is_latin_square</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self, Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#73-82' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns <code>true</code> if latin squareness holds for the given arguments. <a href="../../alga/general/one_operator/trait.AbstractQuasigroup.html#method.prop_inv_is_latin_square">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-AbstractSemigroup%3CMultiplicative%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/one_operator/trait.AbstractSemigroup.html" title="trait alga::general::one_operator::AbstractSemigroup">AbstractSemigroup</a><<a class="struct" href="../../alga/general/operator/struct.Multiplicative.html" title="struct alga::general::operator::Multiplicative">Multiplicative</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractSemigroup%3CMultiplicative%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#54' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.prop_is_associative_approx' class="method hidden"><code id='prop_is_associative_approx.v'>fn <a href='../../alga/general/one_operator/trait.AbstractSemigroup.html#method.prop_is_associative_approx' class='fnname'>prop_is_associative_approx</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self, Self, Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="../../approx/relative_eq/trait.RelativeEq.html" title="trait approx::relative_eq::RelativeEq">RelativeEq</a><Self>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#128-134' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns <code>true</code> if associativity holds for the given arguments. Approximate equality is used for verifications. <a href="../../alga/general/one_operator/trait.AbstractSemigroup.html#method.prop_is_associative_approx">Read more</a></p>
|
||
|
|
</div><h4 id='method.prop_is_associative' class="method hidden"><code id='prop_is_associative.v'>fn <a href='../../alga/general/one_operator/trait.AbstractSemigroup.html#method.prop_is_associative' class='fnname'>prop_is_associative</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self, Self, Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#137-143' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns <code>true</code> if associativity holds for the given arguments.</p>
|
||
|
|
</div></div><h3 id='impl-AbstractSemigroup%3CAdditive%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/one_operator/trait.AbstractSemigroup.html" title="trait alga::general::one_operator::AbstractSemigroup">AbstractSemigroup</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractSemigroup%3CAdditive%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#54' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.prop_is_associative_approx-1' class="method hidden"><code id='prop_is_associative_approx.v-1'>fn <a href='../../alga/general/one_operator/trait.AbstractSemigroup.html#method.prop_is_associative_approx' class='fnname'>prop_is_associative_approx</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self, Self, Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="../../approx/relative_eq/trait.RelativeEq.html" title="trait approx::relative_eq::RelativeEq">RelativeEq</a><Self>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#128-134' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns <code>true</code> if associativity holds for the given arguments. Approximate equality is used for verifications. <a href="../../alga/general/one_operator/trait.AbstractSemigroup.html#method.prop_is_associative_approx">Read more</a></p>
|
||
|
|
</div><h4 id='method.prop_is_associative-1' class="method hidden"><code id='prop_is_associative.v-1'>fn <a href='../../alga/general/one_operator/trait.AbstractSemigroup.html#method.prop_is_associative' class='fnname'>prop_is_associative</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self, Self, Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#137-143' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns <code>true</code> if associativity holds for the given arguments.</p>
|
||
|
|
</div></div><h3 id='impl-AbstractLoop%3CAdditive%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/one_operator/trait.AbstractLoop.html" title="trait alga::general::one_operator::AbstractLoop">AbstractLoop</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractLoop%3CAdditive%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#54' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-AbstractMonoid%3CMultiplicative%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/one_operator/trait.AbstractMonoid.html" title="trait alga::general::one_operator::AbstractMonoid">AbstractMonoid</a><<a class="struct" href="../../alga/general/operator/struct.Multiplicative.html" title="struct alga::general::operator::Multiplicative">Multiplicative</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractMonoid%3CMultiplicative%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#54' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.prop_operating_identity_element_is_noop_approx' class="method hidden"><code id='prop_operating_identity_element_is_noop_approx.v'>fn <a href='../../alga/general/one_operator/trait.AbstractMonoid.html#method.prop_operating_identity_element_is_noop_approx' class='fnname'>prop_operating_identity_element_is_noop_approx</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">,)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="../../approx/relative_eq/trait.RelativeEq.html" title="trait approx::relative_eq::RelativeEq">RelativeEq</a><Self>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#242-249' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Checks whether operating with the identity element is a no-op for the given argument. Approximate equality is used for verifications. <a href="../../alga/general/one_operator/trait.AbstractMonoid.html#method.prop_operating_identity_element_is_noop_approx">Read more</a></p>
|
||
|
|
</div><h4 id='method.prop_operating_identity_element_is_noop' class="method hidden"><code id='prop_operating_identity_element_is_noop.v'>fn <a href='../../alga/general/one_operator/trait.AbstractMonoid.html#method.prop_operating_identity_element_is_noop' class='fnname'>prop_operating_identity_element_is_noop</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">,)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#253-259' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Checks whether operating with the identity element is a no-op for the given argument. <a href="../../alga/general/one_operator/trait.AbstractMonoid.html#method.prop_operating_identity_element_is_noop">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-AbstractMonoid%3CAdditive%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/one_operator/trait.AbstractMonoid.html" title="trait alga::general::one_operator::AbstractMonoid">AbstractMonoid</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractMonoid%3CAdditive%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#54' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.prop_operating_identity_element_is_noop_approx-1' class="method hidden"><code id='prop_operating_identity_element_is_noop_approx.v-1'>fn <a href='../../alga/general/one_operator/trait.AbstractMonoid.html#method.prop_operating_identity_element_is_noop_approx' class='fnname'>prop_operating_identity_element_is_noop_approx</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">,)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="../../approx/relative_eq/trait.RelativeEq.html" title="trait approx::relative_eq::RelativeEq">RelativeEq</a><Self>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#242-249' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Checks whether operating with the identity element is a no-op for the given argument. Approximate equality is used for verifications. <a href="../../alga/general/one_operator/trait.AbstractMonoid.html#method.prop_operating_identity_element_is_noop_approx">Read more</a></p>
|
||
|
|
</div><h4 id='method.prop_operating_identity_element_is_noop-1' class="method hidden"><code id='prop_operating_identity_element_is_noop.v-1'>fn <a href='../../alga/general/one_operator/trait.AbstractMonoid.html#method.prop_operating_identity_element_is_noop' class='fnname'>prop_operating_identity_element_is_noop</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">,)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#253-259' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Checks whether operating with the identity element is a no-op for the given argument. <a href="../../alga/general/one_operator/trait.AbstractMonoid.html#method.prop_operating_identity_element_is_noop">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-AbstractGroup%3CAdditive%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/one_operator/trait.AbstractGroup.html" title="trait alga::general::one_operator::AbstractGroup">AbstractGroup</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractGroup%3CAdditive%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#54' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-AbstractGroupAbelian%3CAdditive%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/one_operator/trait.AbstractGroupAbelian.html" title="trait alga::general::one_operator::AbstractGroupAbelian">AbstractGroupAbelian</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractGroupAbelian%3CAdditive%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#54' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.prop_is_commutative_approx' class="method hidden"><code id='prop_is_commutative_approx.v'>fn <a href='../../alga/general/one_operator/trait.AbstractGroupAbelian.html#method.prop_is_commutative_approx' class='fnname'>prop_is_commutative_approx</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self, Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="../../approx/relative_eq/trait.RelativeEq.html" title="trait approx::relative_eq::RelativeEq">RelativeEq</a><Self>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#351-357' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns <code>true</code> if the operator is commutative for the given argument tuple. Approximate equality is used for verifications. <a href="../../alga/general/one_operator/trait.AbstractGroupAbelian.html#method.prop_is_commutative_approx">Read more</a></p>
|
||
|
|
</div><h4 id='method.prop_is_commutative' class="method hidden"><code id='prop_is_commutative.v'>fn <a href='../../alga/general/one_operator/trait.AbstractGroupAbelian.html#method.prop_is_commutative' class='fnname'>prop_is_commutative</a>(args: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self, Self<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>, </span></code><a class='srclink' href='../../src/alga/general/one_operator.rs.html#360-366' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns <code>true</code> if the operator is commutative for the given argument tuple.</p>
|
||
|
|
</div></div><h3 id='impl-Identity%3CMultiplicative%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/identity/trait.Identity.html" title="trait alga::general::identity::Identity">Identity</a><<a class="struct" href="../../alga/general/operator/struct.Multiplicative.html" title="struct alga::general::operator::Multiplicative">Multiplicative</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Identity%3CMultiplicative%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#17-22' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.identity-1' class="method hidden"><code id='identity.v-1'>fn <a href='../../alga/general/identity/trait.Identity.html#tymethod.identity' class='fnname'>identity</a>() -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#19-21' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The identity element.</p>
|
||
|
|
</div><h4 id='method.id' class="method hidden"><code id='id.v'>fn <a href='../../alga/general/identity/trait.Identity.html#method.id' class='fnname'>id</a>(O) -> Self</code><a class='srclink' href='../../src/alga/general/identity.rs.html#27-32' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Specific identity.</p>
|
||
|
|
</div></div><h3 id='impl-Identity%3CAdditive%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/identity/trait.Identity.html" title="trait alga::general::identity::Identity">Identity</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Identity%3CAdditive%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#24-29' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.identity-2' class="method hidden"><code id='identity.v-2'>fn <a href='../../alga/general/identity/trait.Identity.html#tymethod.identity' class='fnname'>identity</a>() -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#26-28' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The identity element.</p>
|
||
|
|
</div><h4 id='method.id-1' class="method hidden"><code id='id.v-1'>fn <a href='../../alga/general/identity/trait.Identity.html#method.id' class='fnname'>id</a>(O) -> Self</code><a class='srclink' href='../../src/alga/general/identity.rs.html#27-32' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Specific identity.</p>
|
||
|
|
</div></div><h3 id='impl-TwoSidedInverse%3CAdditive%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/operator/trait.TwoSidedInverse.html" title="trait alga::general::operator::TwoSidedInverse">TwoSidedInverse</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-TwoSidedInverse%3CAdditive%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#45-50' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.two_sided_inverse' class="method hidden"><code id='two_sided_inverse.v'>fn <a href='../../alga/general/operator/trait.TwoSidedInverse.html#tymethod.two_sided_inverse' class='fnname'>two_sided_inverse</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#47-49' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns the two_sided_inverse of <code>self</code>, relative to the operator <code>O</code>. <a href="../../alga/general/operator/trait.TwoSidedInverse.html#tymethod.two_sided_inverse">Read more</a></p>
|
||
|
|
</div><h4 id='method.two_sided_inverse_mut' class="method hidden"><code id='two_sided_inverse_mut.v'>fn <a href='../../alga/general/operator/trait.TwoSidedInverse.html#method.two_sided_inverse_mut' class='fnname'>two_sided_inverse_mut</a>(&mut self)</code><a class='srclink' href='../../src/alga/general/operator.rs.html#28-30' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>In-place inversion of <code>self</code>, relative to the operator <code>O</code>. <a href="../../alga/general/operator/trait.TwoSidedInverse.html#method.two_sided_inverse_mut">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-SubsetOf%3CQuaternion%3CN2%3E%3E' class='impl'><code class='in-band'>impl<N1, N2> <a class="trait" href="../../alga/general/subset/trait.SubsetOf.html" title="trait alga::general::subset::SubsetOf">SubsetOf</a><<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N2>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N1> <span class="where fmt-newline">where<br> N1: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>,<br> N2: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a> + <a class="trait" href="../../alga/general/subset/trait.SupersetOf.html" title="trait alga::general::subset::SupersetOf">SupersetOf</a><N1>, </span></code><a href='#impl-SubsetOf%3CQuaternion%3CN2%3E%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_conversion.rs.html#35-56' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.to_superset' class="method hidden"><code id='to_superset.v'>fn <a href='../../alga/general/subset/trait.SubsetOf.html#tymethod.to_superset' class='fnname'>to_superset</a>(&self) -> <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N2></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_conversion.rs.html#41-43' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The inclusion map: converts <code>self</code> to the equivalent element of its superset.</p>
|
||
|
|
</div><h4 id='method.is_in_subset' class="method hidden"><code id='is_in_subset.v'>fn <a href='../../alga/general/subset/trait.SubsetOf.html#tymethod.is_in_subset' class='fnname'>is_in_subset</a>(q: &<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N2>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_conversion.rs.html#46-48' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Checks if <code>element</code> is actually part of the subset <code>Self</code> (and can be converted to it).</p>
|
||
|
|
</div><h4 id='method.from_superset_unchecked' class="method hidden"><code id='from_superset_unchecked.v'>unsafe fn <a href='../../alga/general/subset/trait.SubsetOf.html#tymethod.from_superset_unchecked' class='fnname'>from_superset_unchecked</a>(q: &<a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N2>) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_conversion.rs.html#51-55' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Use with care! Same as <code>self.to_superset</code> but without any property checks. Always succeeds.</p>
|
||
|
|
</div><h4 id='method.from_superset' class="method hidden"><code id='from_superset.v'>fn <a href='../../alga/general/subset/trait.SubsetOf.html#method.from_superset' class='fnname'>from_superset</a>(element: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>T) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><Self></code><a class='srclink' href='../../src/alga/general/subset.rs.html#32-38' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The inverse inclusion map: attempts to construct <code>self</code> from the equivalent element of its superset. <a href="../../alga/general/subset/trait.SubsetOf.html#method.from_superset">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-AbstractModule%3CAdditive%2C%20Additive%2C%20Multiplicative%3E' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/module/trait.AbstractModule.html" title="trait alga::general::module::AbstractModule">AbstractModule</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>, <a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>, <a class="struct" href="../../alga/general/operator/struct.Multiplicative.html" title="struct alga::general::operator::Multiplicative">Multiplicative</a>> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-AbstractModule%3CAdditive%2C%20Additive%2C%20Multiplicative%3E' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#76-83' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.AbstractRing' class="type"><code id='AbstractRing.t'>type <a href='../../alga/general/module/trait.AbstractModule.html#associatedtype.AbstractRing' class="type">AbstractRing</a> = N</code></h4><div class='docblock'><p>The underlying scalar field.</p>
|
||
|
|
</div><h4 id='method.multiply_by' class="method hidden"><code id='multiply_by.v'>fn <a href='../../alga/general/module/trait.AbstractModule.html#tymethod.multiply_by' class='fnname'>multiply_by</a>(&self, n: N) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#80-82' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Multiplies an element of the ring with an element of the module.</p>
|
||
|
|
</div></div><h3 id='impl-Module' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/general/specialized/trait.Module.html" title="trait alga::general::specialized::Module">Module</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-Module' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#85-87' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Ring' class="type"><code id='Ring.t'>type <a href='../../alga/general/specialized/trait.Module.html#associatedtype.Ring' class="type">Ring</a> = N</code></h4><div class='docblock'><p>The underlying scalar field.</p>
|
||
|
|
</div></div><h3 id='impl-FiniteDimVectorSpace' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/linear/vector/trait.FiniteDimVectorSpace.html" title="trait alga::linear::vector::FiniteDimVectorSpace">FiniteDimVectorSpace</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-FiniteDimVectorSpace' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#93-118' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.dimension' class="method hidden"><code id='dimension.v'>fn <a href='../../alga/linear/vector/trait.FiniteDimVectorSpace.html#tymethod.dimension' class='fnname'>dimension</a>() -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#95-97' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The vector space dimension.</p>
|
||
|
|
</div><h4 id='method.canonical_basis_element' class="method hidden"><code id='canonical_basis_element.v'>fn <a href='../../alga/linear/vector/trait.FiniteDimVectorSpace.html#tymethod.canonical_basis_element' class='fnname'>canonical_basis_element</a>(i: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#100-102' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The i-the canonical basis element.</p>
|
||
|
|
</div><h4 id='method.dot-1' class="method hidden"><code id='dot.v-1'>fn <a href='../../alga/linear/vector/trait.FiniteDimVectorSpace.html#tymethod.dot' class='fnname'>dot</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#105-107' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The dot product between two vectors.</p>
|
||
|
|
</div><h4 id='method.component_unchecked' class="method hidden"><code id='component_unchecked.v'>unsafe fn <a href='../../alga/linear/vector/trait.FiniteDimVectorSpace.html#tymethod.component_unchecked' class='fnname'>component_unchecked</a>(&self, i: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#110-112' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Same as <code>&self[i]</code> but without bound-checking.</p>
|
||
|
|
</div><h4 id='method.component_unchecked_mut' class="method hidden"><code id='component_unchecked_mut.v'>unsafe fn <a href='../../alga/linear/vector/trait.FiniteDimVectorSpace.html#tymethod.component_unchecked_mut' class='fnname'>component_unchecked_mut</a>(&mut self, i: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#115-117' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Same as <code>&mut self[i]</code> but without bound-checking.</p>
|
||
|
|
</div><h4 id='method.canonical_basis' class="method hidden"><code id='canonical_basis.v'>fn <a href='../../alga/linear/vector/trait.FiniteDimVectorSpace.html#method.canonical_basis' class='fnname'>canonical_basis</a><F>(f: F) <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, </span></code><a class='srclink' href='../../src/alga/linear/vector.rs.html#90-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Applies the given closule to each element of this vector space's canonical basis. Stops if <code>f</code> returns <code>false</code>. <a href="../../alga/linear/vector/trait.FiniteDimVectorSpace.html#method.canonical_basis">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-NormedSpace' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/linear/vector/trait.NormedSpace.html" title="trait alga::linear::vector::NormedSpace">NormedSpace</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-NormedSpace' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#120-158' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.RealField' class="type"><code id='RealField.t'>type <a href='../../alga/linear/vector/trait.NormedSpace.html#associatedtype.RealField' class="type">RealField</a> = N</code></h4><div class='docblock'><p>The result of the norm (not necessarily the same same as the field used by this vector space).</p>
|
||
|
|
</div><h4 id='associatedtype.ComplexField' class="type"><code id='ComplexField.t'>type <a href='../../alga/linear/vector/trait.NormedSpace.html#associatedtype.ComplexField' class="type">ComplexField</a> = N</code></h4><div class='docblock'><p>The field of this space must be this complex number.</p>
|
||
|
|
</div><h4 id='method.norm_squared-1' class="method hidden"><code id='norm_squared.v-1'>fn <a href='../../alga/linear/vector/trait.NormedSpace.html#tymethod.norm_squared' class='fnname'>norm_squared</a>(&self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#125-127' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The squared norm of this vector.</p>
|
||
|
|
</div><h4 id='method.norm-1' class="method hidden"><code id='norm.v-1'>fn <a href='../../alga/linear/vector/trait.NormedSpace.html#tymethod.norm' class='fnname'>norm</a>(&self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#130-132' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The norm of this vector.</p>
|
||
|
|
</div><h4 id='method.normalize-1' class="method hidden"><code id='normalize.v-1'>fn <a href='../../alga/linear/vector/trait.NormedSpace.html#tymethod.normalize' class='fnname'>normalize</a>(&self) -> Self</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#135-138' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns a normalized version of this vector.</p>
|
||
|
|
</div><h4 id='method.normalize_mut-1' class="method hidden"><code id='normalize_mut.v-1'>fn <a href='../../alga/linear/vector/trait.NormedSpace.html#tymethod.normalize_mut' class='fnname'>normalize_mut</a>(&mut self) -> N</code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#141-143' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Normalizes this vector in-place and returns its norm.</p>
|
||
|
|
</div><h4 id='method.try_normalize' class="method hidden"><code id='try_normalize.v'>fn <a href='../../alga/linear/vector/trait.NormedSpace.html#tymethod.try_normalize' class='fnname'>try_normalize</a>(&self, min_norm: N) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><Self></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#146-152' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns a normalized version of this vector unless its norm as smaller or equal to <code>eps</code>.</p>
|
||
|
|
</div><h4 id='method.try_normalize_mut' class="method hidden"><code id='try_normalize_mut.v'>fn <a href='../../alga/linear/vector/trait.NormedSpace.html#tymethod.try_normalize_mut' class='fnname'>try_normalize_mut</a>(&mut self, min_norm: N) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><N></code><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#155-157' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Normalizes this vector in-place or does nothing if its norm is smaller or equal to <code>eps</code>. <a href="../../alga/linear/vector/trait.NormedSpace.html#tymethod.try_normalize_mut">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-VectorSpace' class='impl'><code class='in-band'>impl<N: <a class="trait" href="../../nalgebra/trait.RealField.html" title="trait nalgebra::RealField">RealField</a>> <a class="trait" href="../../alga/linear/vector/trait.VectorSpace.html" title="trait alga::linear::vector::VectorSpace">VectorSpace</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N></code><a href='#impl-VectorSpace' class='anchor'></a><a class='srclink' href='../../src/nalgebra/geometry/quaternion_alga.rs.html#89-91' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Field' class="type"><code id='Field.t'>type <a href='../../alga/linear/vector/trait.VectorSpace.html#associatedtype.Field' class="type">Field</a> = N</code></h4><div class='docblock'><p>The underlying scalar field.</p>
|
||
|
|
</div></div></div><h2 id='synthetic-implementations' class='small-section-header'>Auto Trait Implementations<a href='#synthetic-implementations' class='anchor'></a></h2><div id='synthetic-implementations-list'><h3 id='impl-Send' class='impl'><code class='in-band'>impl<N> <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> N: <a class="trait" href="../../nalgebra/base/trait.Scalar.html" title="trait nalgebra::base::Scalar">Scalar</a>, </span></code><a href='#impl-Send' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-Unpin' class='impl'><code class='in-band'>impl<N> <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> N: <a class="trait" href="../../nalgebra/base/trait.Scalar.html" title="trait nalgebra::base::Scalar">Scalar</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a>, </span></code><a href='#impl-Unpin' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-Sync' class='impl'><code class='in-band'>impl<N> <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> N: <a class="trait" href="../../nalgebra/base/trait.Scalar.html" title="trait nalgebra::base::Scalar">Scalar</a>, </span></code><a href='#impl-Sync' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-UnwindSafe' class='impl'><code class='in-band'>impl<N> <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> N: <a class="trait" href="../../nalgebra/base/trait.Scalar.html" title="trait nalgebra::base::Scalar">Scalar</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>, </span></code><a href='#impl-UnwindSafe' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-RefUnwindSafe' class='impl'><code class='in-band'>impl<N> <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a> for <a class="struct" href="../../nalgebra/geometry/struct.Quaternion.html" title="struct nalgebra::geometry::Quaternion">Quaternion</a><N> <span class="where fmt-newline">where<br> N: <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a> + <a class="trait" href="../../nalgebra/base/trait.Scalar.html" title="trait nalgebra::base::Scalar">Scalar</a>, </span></code><a href='#impl-RefUnwindSafe' class='anchor'></a></h3><div class='impl-items'></div></div><h2 id='blanket-implementations' class='small-section-header'>Blanket Implementations<a href='#blanket-implementations' class='anchor'></a></h2><div id='blanket-implementations-list'><h3 id='impl-ToOwned' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org
|
||
|
|
</div><h4 id='method.to_owned' class="method hidden"><code id='to_owned.v'>fn <a href='https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#tymethod.to_owned' class='fnname'>to_owned</a>(&self) -> T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#85-87' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates owned data from borrowed data, usually by cloning. <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#tymethod.to_owned">Read more</a></p>
|
||
|
|
</div><h4 id='method.clone_into' class="method hidden"><code id='clone_into.v'>fn <a href='https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#method.clone_into' class='fnname'>clone_into</a>(&self, target: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>T)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#89-91' title='goto source code'>[src]</a></h4><div class='stability hidden'><div class='stab unstable'><details><summary><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>toowned_clone_into</code>)</summary><p>recently added</p>
|
||
|
|
</details></div></div><div class='docblock hidden'><p>Uses borrowed data to replace owned data, usually by cloning. <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#method.clone_into">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-Into%3CU%3E' class='impl'><code class='in-band'>impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><T>, </span></code><a href='#impl-Into%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#544-549' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.into' class="method hidden"><code id='into.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.Into.html#tymethod.into' class='fnname'>into</a>(self) -> U</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#546-548' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
|
||
|
|
</div></div><h3 id='impl-From%3CT%3E' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><T> for T</code><a href='#impl-From%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#553-555' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from-1' class="method hidden"><code id='from.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(t: T) -> T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#554' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
|
||
|
|
</div></div><h3 id='impl-ToString' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/alloc/string/trait.ToString.html" title="trait alloc::string::ToString">ToString</a> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html" title="trait core::fmt::Display">Display</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></code><a href='#impl-ToString' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/string.rs.html#2134-2144' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.to_string' class="method hidden"><code id='to_string.v'>default fn <a href='https://doc.rust-lang.org/nightly/alloc/string/trait.ToString.html#tymethod.to_string' class='fnname'>to_string</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/string/struct.String.html" title="struct alloc::string::String">String</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/string.rs.html#2136-2143' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Converts the given value to a <code>String</code>. <a href="https://doc.rust-lang.org/nightly/alloc/string/trait.ToString.html#tymethod.to_string">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-TryFrom%3CU%3E' class='impl'><code class='in-band'>impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><T>, </span></code><a href='#impl-TryFrom%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#572-578' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error' class="type"><code id='Error.t'>type <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
|
||
|
|
</div><h4 id='method.try_from' class="method hidden"><code id='try_from.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(value: U) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><T, <T as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#575-577' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
|
||
|
|
</div></div><h3 id='impl-TryInto%3CU%3E' class='impl'><code class='in-band'>impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>, </span></code><a href='#impl-TryInto%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#560-567' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error-1' class="type"><code id='Error.t-1'>type <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#associatedtype.Error' class="type">Error</a> = <U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
|
||
|
|
</div><h4 id='method.try_into' class="method hidden"><code id='try_into.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#tymethod.try_into' class='fnname'>try_into</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><U, <U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#564-566' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
|
||
|
|
</div></div><h3 id='impl-BorrowMut%3CT%3E' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a><T> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></code><a href='#impl-BorrowMut%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#218-220' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow_mut' class="method hidden"><code id='borrow_mut.v'>fn <a href='https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut' class='fnname'>borrow_mut</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#219' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-Borrow%3CT%3E' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a><T> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></code><a href='#impl-Borrow%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#213-215' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow' class="method hidden"><code id='borrow.v'>fn <a href='https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow' class='fnname'>borrow</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#214' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-Any' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T <span class="where fmt-newline">where<br> T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></code><a href='#impl-Any' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/any.rs.html#100-102' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.type_id' class="method hidden"><code id='type_id.v'>fn <a href='https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id' class='fnname'>type_id</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/any.rs.html#101' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id">Read more</a></p>
|
||
|
|
</div></div><h3 id='impl-Same%3CT%3E' class='impl'><code class='in-band'>impl<T> <a class="trait" href="../../typenum/type_operators/trait.Same.html" title="trait typenum::type_operators::Same">Same</a><T> for T</code><a href='#impl-Same%3CT%3E' class='anchor'></a><a class='srclink' href='../../src/typenum/type_operators.rs.html#32-34' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output-23' class="type"><code id='Output.t-23'>type <a href='../../typenum/type_operators/trait.Same.html#associatedtype.Output' class="type">Output</a> = T</code></h4><div class='docblock'><p>Should always be <code>Self</code></p>
|
||
|
|
</div></div><h3 id='impl-ClosedNeg' class='impl'><code class='in-band'>impl<T> <a class="trait" href="../../alga/general/operator/trait.ClosedNeg.html" title="trait alga::general::operator::ClosedNeg">ClosedNeg</a> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Neg.html" title="trait core::ops::arith::Neg">Neg</a><Output = T>, </span></code><a href='#impl-ClosedNeg' class='anchor'></a><a class='srclink' href='../../src/alga/general/operator.rs.html#144' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-SupersetOf%3CSS%3E' class='impl'><code class='in-band'>impl<SS, SP> <a class="trait" href="../../alga/general/subset/trait.SupersetOf.html" title="trait alga::general::subset::SupersetOf">SupersetOf</a><SS> for SP <span class="where fmt-newline">where<br> SS: <a class="trait" href="../../alga/general/subset/trait.SubsetOf.html" title="trait alga::general::subset::SubsetOf">SubsetOf</a><SP>, </span></code><a href='#impl-SupersetOf%3CSS%3E' class='anchor'></a><a class='srclink' href='../../src/alga/general/subset.rs.html#87-107' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.to_subset' class="method hidden"><code id='to_subset.v'>fn <a href='../../alga/general/subset/trait.SupersetOf.html#method.to_subset' class='fnname'>to_subset</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><SS></code><a class='srclink' href='../../src/alga/general/subset.rs.html#89-91' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The inverse inclusion map: attempts to construct <code>self</code> from the equivalent element of its superset. <a href="../../alga/general/subset/trait.SupersetOf.html#method.to_subset">Read more</a></p>
|
||
|
|
</div><h4 id='method.is_in_subset-1' class="method hidden"><code id='is_in_subset.v-1'>fn <a href='../../alga/general/subset/trait.SupersetOf.html#tymethod.is_in_subset' class='fnname'>is_in_subset</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../../src/alga/general/subset.rs.html#94-96' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Checks if <code>self</code> is actually part of its subset <code>T</code> (and can be converted to it).</p>
|
||
|
|
</div><h4 id='method.to_subset_unchecked' class="method hidden"><code id='to_subset_unchecked.v'>unsafe fn <a href='../../alga/general/subset/trait.SupersetOf.html#tymethod.to_subset_unchecked' class='fnname'>to_subset_unchecked</a>(&self) -> SS</code><a class='srclink' href='../../src/alga/general/subset.rs.html#99-101' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Use with care! Same as <code>self.to_subset</code> but without any property checks. Always succeeds.</p>
|
||
|
|
</div><h4 id='method.from_subset' class="method hidden"><code id='from_subset.v'>fn <a href='../../alga/general/subset/trait.SupersetOf.html#tymethod.from_subset' class='fnname'>from_subset</a>(element: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>SS) -> SP</code><a class='srclink' href='../../src/alga/general/subset.rs.html#104-106' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>The inclusion map: converts <code>self</code> to the equivalent element of its superset.</p>
|
||
|
|
</div></div><h3 id='impl-ClosedAdd%3CRight%3E' class='impl'><code class='in-band'>impl<T, Right> <a class="trait" href="../../alga/general/operator/trait.ClosedAdd.html" title="trait alga::general::operator::ClosedAdd">ClosedAdd</a><Right> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Add.html" title="trait core::ops::arith::Add">Add</a><Right, Output = T> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.AddAssign.html" title="trait core::ops::arith::AddAssign">AddAssign</a><Right>, </span></code><a href='#impl-ClosedAdd%3CRight%3E' class='anchor'></a><a class='srclink' href='../../src/alga/general/operator.rs.html#140' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-ClosedSub%3CRight%3E' class='impl'><code class='in-band'>impl<T, Right> <a class="trait" href="../../alga/general/operator/trait.ClosedSub.html" title="trait alga::general::operator::ClosedSub">ClosedSub</a><Right> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Sub.html" title="trait core::ops::arith::Sub">Sub</a><Right, Output = T> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.SubAssign.html" title="trait core::ops::arith::SubAssign">SubAssign</a><Right>, </span></code><a href='#impl-ClosedSub%3CRight%3E' class='anchor'></a><a class='srclink' href='../../src/alga/general/operator.rs.html#141' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-ClosedMul%3CRight%3E' class='impl'><code class='in-band'>impl<T, Right> <a class="trait" href="../../alga/general/operator/trait.ClosedMul.html" title="trait alga::general::operator::ClosedMul">ClosedMul</a><Right> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Mul.html" title="trait core::ops::arith::Mul">Mul</a><Right, Output = T> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.MulAssign.html" title="trait core::ops::arith::MulAssign">MulAssign</a><Right>, </span></code><a href='#impl-ClosedMul%3CRight%3E' class='anchor'></a><a class='srclink' href='../../src/alga/general/operator.rs.html#142' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-ClosedDiv%3CRight%3E' class='impl'><code class='in-band'>impl<T, Right> <a class="trait" href="../../alga/general/operator/trait.ClosedDiv.html" title="trait alga::general::operator::ClosedDiv">ClosedDiv</a><Right> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.Div.html" title="trait core::ops::arith::Div">Div</a><Right, Output = T> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/arith/trait.DivAssign.html" title="trait core::ops::arith::DivAssign">DivAssign</a><Right>, </span></code><a href='#impl-ClosedDiv%3CRight%3E' class='anchor'></a><a class='srclink' href='../../src/alga/general/operator.rs.html#143' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-AdditiveMagma' class='impl'><code class='in-band'>impl<T> <a class="trait" href="../../alga/general/specialized/trait.AdditiveMagma.html" title="trait alga::general::specialized::AdditiveMagma">AdditiveMagma</a> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="../../alga/general/one_operator/trait.AbstractMagma.html" title="trait alga::general::one_operator::AbstractMagma">AbstractMagma</a><<a class="struct" href="../../alga/general/operator/struct.Additive.html" title="struct alga::general::operator::Additive">Additive</a>>, </span></code><a href='#impl-AdditiveMagma' class='anchor'></a><a cla
|