Struct shades::Var

pub struct Var<T>(_)
 where
    T: ?Sized;

Mutable variable.

A Var<T> is akin to an Expr<T> that can be mutated. You can go from a Var<T> to an Expr<T> via either the From or Var::to_expr method.

Variables, because they allow mutations, allow to write more complicated shader functions. Also, lots of graphics pipelines’ properties are variables you will have to write to, such as VertexShaderEnv::position.

Implementations

impl<T> Var<T> where
    T: ?Sized, 

pub fn to_expr(&self) -> Expr<T>

Coerce Var<T> into Expr<T>.

Remember that doing so will move the Var<T>. clone it if you want to preserve the source variable.

Note: use this function only when necessary. Lots of functions will accept both Expr<T> and Var<T>, performing the coercion for you automatically.

Return

The expression representation of Var<T>, allowing to pass the variable to functions or expressions that don’t easily coerce it automatically to Expr<T> already.

Examples

let v = s.var(123); // Var<i32>
let e = v.to_expr(); // Expr<i32>

impl<T> Var<[T]>

pub fn at(&self, index: impl Into<Expr<i32>>) -> Var<T>

impl<T, const N: usize> Var<[T; N]>

pub fn at(&self, index: impl Into<Expr<i32>>) -> Var<T>

Methods from Deref<Target = Expr<T>>

pub fn eq(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Equality expression.

This method builds an expression representing the equality between two expressions.

Return

An Expr<bool> representing the equality between the two input expressions.

Examples

use shades::{lit, vec2};

let _ = lit!(1).eq(1); // 1 == 1;
let _ = vec2!(1., 2.).eq(vec2!(0., 0.)); // vec2(1., 2.) == vec2(0., 0.)

pub fn neq(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Inequality expression.

This method builds an expression representing the inequality between two expressions.

Return

An Expr<bool> representing the inequality between the two input expressions.

Examples

use shades::{lit, vec2};

let _ = lit!(1).neq(1); // 1 != 1;
let _ = vec2!(1., 2.).eq(vec2!(0., 0.)); // vec2(1., 2.) != vec2(0., 0.)

pub fn lt(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Less-than expression.

This method builds an expression representing the binary operation a < b.

Return

An Expr<bool> representing a < b.

Examples

use shades::lit;

let _ = lit!(1).lt(2); // 1 < 2;

pub fn lte(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Less-than-or-equal expression.

This method builds an expression representing the binary operation a <= b.

Return

An Expr<bool> representing a <= b.

Examples

use shades::lit;

let _ = lit!(1).lte(2); // 1 <= 2;

pub fn gt(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Greater-than expression.

This method builds an expression representing the binary operation a > b.

Return

An Expr<bool> representing a > b.

Examples

use shades::lit;

let _ = lit!(1).gt(2); // 1 > 2;

pub fn gte(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Less-than-or-equal expression.

This method builds an expression representing the binary operation a <= b.

Return

An Expr<bool> representing a <= b.

Examples

use shades::lit;

let _ = lit!(1).lte(2); // 1 <= 2;

pub fn and(&self, rhs: impl Into<Expr<bool>>) -> Expr<bool>

Logical and expression.

This method builds an expression representing the logical operation a AND b.

Return

An Expr<bool> representing a AND b.

Examples

use shades::lit;

let _ = lit!(true).and(false); // true && false

pub fn or(&self, rhs: impl Into<Expr<bool>>) -> Expr<bool>

Logical or expression.

This method builds an expression representing the logical operation a OR b.

Return

An Expr<bool> representing a OR b.

Examples

use shades::lit;

let _ = lit!(true).or(false); // true || false

pub fn xor(&self, rhs: impl Into<Expr<bool>>) -> Expr<bool>

Logical exclusive or expression.

This method builds an expression representing the logical operation a XOR b.

Return

An Expr<bool> representing a XOR b.

Examples

use shades::lit;

let _ = lit!(true).xor(false); // true ^^ false

pub fn at(&self, index: impl Into<Expr<i32>>) -> Expr<T>

Array lookup.

The expression a.at(i) represents an array lookup, where a is an array — which type must be either Expr<[T]> or Expr<[T; N]> – and i is an Expr<i32>.

Return

The resulting Expr<T> represents the array lookup in a at index i.

Examples

use shades::lit;

let _ = lit!([1, 2, 3]).at(2); // [1, 2, 3][2]

pub fn at(&self, index: impl Into<Expr<i32>>) -> Expr<T>

Array lookup.

The expression a.at(i) represents an array lookup, where a is an array — which type must be either Expr<[T]> or Expr<[T; N]> – and i is an Expr<i32>.

Return

The resulting Expr<T> represents the array lookup in a at index i.

Examples

use shades::lit;

let _ = lit!([1, 2, 3]).at(2); // [1, 2, 3][2]

pub fn position(&self) -> Expr<V4<f32>>

pub fn point_size(&self) -> Expr<f32>

pub fn clip_distance(&self) -> Expr<[f32]>

pub fn cull_distance(&self) -> Expr<[f32]>

pub fn position(&self) -> Var<V4<f32>>

4D position of the verte.

pub fn point_size(&self) -> Var<f32>

Point size of the vertex.

pub fn clip_distance(&self) -> Var<[f32]>

Clip distances to user-defined planes.

pub fn cull_distance(&self) -> Var<[f32]>

Cull distances to user-defined planes.

pub fn position(&self) -> Expr<V4<f32>>

4D position of the vertex.

pub fn point_size(&self) -> Expr<f32>

Point size of the vertex.

pub fn clip_distance(&self) -> Expr<[f32]>

Clip distances to user-defined planes.

pub fn cull_distance(&self) -> Expr<[f32]>

Cull distances to user-defined planes.

pub fn position(&self) -> Expr<V4<f32>>

Provides 4D the position of the vertex.

pub fn point_size(&self) -> Expr<f32>

Provides the size point of the vertex if it’s currently being rendered in point mode.

pub fn clip_distance(&self) -> Expr<[f32]>

Clip distances to user planes of the vertex.

pub fn cull_distance(&self) -> Expr<[f32]>

Cull distances to user planes of the vertex.

Trait Implementations

impl<'a> Add<&'a Expr<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Expr<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<f32>>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<i32>>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<u32>>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<f32>>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<i32>>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<u32>>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<f32>>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<i32>>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<u32>>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Var<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V2<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: V2<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V2<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: V2<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V2<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: V2<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V2<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: V2<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V2<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: V2<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V2<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: V2<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V3<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: V3<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V3<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: V3<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V3<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: V3<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V3<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: V3<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V3<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: V3<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V3<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: V3<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V4<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: V4<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V4<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: V4<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V4<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: V4<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V4<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: V4<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V4<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: V4<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<V4<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: V4<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<f32>>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<i32>>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<u32>>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<f32>>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<i32>>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<u32>>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<f32>>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<i32>>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<u32>>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Var<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Var<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<f32> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<'a> Add<f32> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<'a> Add<f32> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<'a> Add<f32> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<'a> Add<f32> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<'a> Add<f32> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<'a> Add<f32> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<'a> Add<f32> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<'a> Add<i32> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'a> Add<i32> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'a> Add<i32> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'a> Add<i32> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'a> Add<i32> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'a> Add<i32> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'a> Add<i32> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'a> Add<i32> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'a> Add<u32> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<'a> Add<u32> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<'a> Add<u32> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<'a> Add<u32> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<'a> Add<u32> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<'a> Add<u32> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<'a> Add<u32> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<'a> Add<u32> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<'a> BitAnd<&'a Expr<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Expr<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V2<bool>>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V2<bool>>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V3<bool>>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V3<bool>>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V4<bool>>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V4<bool>>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for Expr<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for &'a Expr<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<&'a Var<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<V2<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: V2<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<V2<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: V2<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<V3<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: V3<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<V3<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: V3<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<V4<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: V4<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<V4<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: V4<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V2<bool>>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V2<bool>>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V3<bool>>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V3<bool>>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V4<bool>>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V4<bool>>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for Expr<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for &'a Expr<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Var<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Var<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<bool> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<bool> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<bool> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<bool> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<bool> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<bool> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<bool> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<bool> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<'a> BitOr<&'a Expr<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Expr<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V2<bool>>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V2<bool>>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V3<bool>>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V3<bool>>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V4<bool>>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V4<bool>>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for Expr<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for &'a Expr<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<&'a Var<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<V2<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: V2<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<V2<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: V2<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<V3<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: V3<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<V3<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: V3<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<V4<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: V4<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<V4<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: V4<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V2<bool>>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V2<bool>>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V3<bool>>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V3<bool>>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V4<bool>>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V4<bool>>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for Expr<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for &'a Expr<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Var<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Var<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<bool> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<'a> BitOr<bool> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<'a> BitOr<bool> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<'a> BitOr<bool> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<'a> BitOr<bool> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<'a> BitOr<bool> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<'a> BitOr<bool> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<'a> BitOr<bool> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<'a> BitXor<&'a Expr<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Expr<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V2<bool>>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V2<bool>>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V3<bool>>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V3<bool>>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V4<bool>>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V4<bool>>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for Expr<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for &'a Expr<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<&'a Var<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<V2<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: V2<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<V2<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: V2<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<V3<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: V3<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<V3<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: V3<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<V4<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: V4<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<V4<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: V4<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V2<bool>>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V2<bool>>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V2<bool>>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V2<bool>>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V3<bool>>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V3<bool>>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V3<bool>>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V3<bool>>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V4<bool>>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V4<bool>>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V4<bool>>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<V4<bool>>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for Expr<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for &'a Expr<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Var<bool>> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Var<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<bool> for Var<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<bool> for &'a Var<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<bool> for Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<bool> for &'a Var<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<bool> for Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<bool> for &'a Var<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<bool> for Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<bool> for &'a Var<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<T> Debug for Var<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Deref for Var<T> where
    T: ?Sized, 

type Target = Expr<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> Div<&'a Expr<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Expr<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<f32>>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<i32>>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<u32>>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<f32>>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<i32>>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<u32>>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<f32>>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<i32>>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<u32>>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Var<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V2<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: V2<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V2<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: V2<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V2<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: V2<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V2<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: V2<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V2<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: V2<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V2<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: V2<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V3<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: V3<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V3<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: V3<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V3<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: V3<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V3<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: V3<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V3<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: V3<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V3<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: V3<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V4<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: V4<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V4<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: V4<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V4<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: V4<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V4<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: V4<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V4<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: V4<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<V4<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: V4<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<f32>>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<i32>>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<u32>>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<f32>>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<i32>>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<u32>>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<f32>>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<i32>>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<u32>>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Var<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Var<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<f32> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<'a> Div<f32> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<'a> Div<f32> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<'a> Div<f32> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<'a> Div<f32> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<'a> Div<f32> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<'a> Div<f32> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<'a> Div<f32> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<'a> Div<i32> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'a> Div<i32> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'a> Div<i32> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'a> Div<i32> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'a> Div<i32> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'a> Div<i32> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'a> Div<i32> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'a> Div<i32> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'a> Div<u32> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<'a> Div<u32> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<'a> Div<u32> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<'a> Div<u32> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<'a> Div<u32> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<'a> Div<u32> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<'a> Div<u32> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<'a> Div<u32> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<'a, T> From<&'a Var<T>> for Var<T> where
    T: ?Sized, 

fn from(v: &'a Self) -> Self

Performs the conversion.

impl<'a, T> From<&'a Var<T>> for Expr<T> where
    T: ?Sized, 

fn from(v: &'a Var<T>) -> Self

Performs the conversion.

impl<T> From<Var<T>> for Expr<T> where
    T: ?Sized, 

fn from(v: Var<T>) -> Self

Performs the conversion.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 2]; 2]>>> for Var<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 2]; 2]>>> for &'a Var<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 2]; 2]>>> for Var<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 2]; 2]>>> for &'a Var<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 3]; 3]>>> for Var<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 3]; 3]>>> for &'a Var<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 3]; 3]>>> for Var<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 3]; 3]>>> for &'a Var<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 4]; 4]>>> for Var<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 4]; 4]>>> for &'a Var<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 4]; 4]>>> for Var<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<Matrix<[[f32; 4]; 4]>>> for &'a Var<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V2<f32>>> for Var<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V2<f32>>> for &'a Var<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V3<f32>>> for Var<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V3<f32>>> for &'a Var<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V4<f32>>> for Var<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V4<f32>>> for &'a Var<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Expr<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 2]; 2]>>> for Expr<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 2]; 2]>>> for Var<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 2]; 2]>>> for &'a Expr<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 2]; 2]>>> for &'a Var<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 2]; 2]>>> for Expr<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 2]; 2]>>> for Var<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 2]; 2]>>> for &'a Expr<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 2]; 2]>>> for &'a Var<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 3]; 3]>>> for Expr<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 3]; 3]>>> for Var<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 3]; 3]>>> for &'a Expr<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 3]; 3]>>> for &'a Var<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 3]; 3]>>> for Expr<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 3]; 3]>>> for Var<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 3]; 3]>>> for &'a Expr<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 3]; 3]>>> for &'a Var<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 4]; 4]>>> for Expr<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 4]; 4]>>> for Var<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 4]; 4]>>> for &'a Expr<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 4]; 4]>>> for &'a Var<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 4]; 4]>>> for Expr<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 4]; 4]>>> for Var<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 4]; 4]>>> for &'a Expr<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<Matrix<[[f32; 4]; 4]>>> for &'a Var<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<f32>>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<f32>>> for Expr<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<f32>>> for Var<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<f32>>> for &'a Expr<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<f32>>> for &'a Var<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<i32>>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<u32>>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<f32>>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<f32>>> for Expr<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<f32>>> for Var<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<f32>>> for &'a Expr<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<f32>>> for &'a Var<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<i32>>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<u32>>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<f32>>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<f32>>> for Expr<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<f32>>> for Var<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<f32>>> for &'a Expr<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<f32>>> for &'a Var<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<i32>>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<u32>>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Var<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 2]; 2]>>> for Var<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 2]; 2]>>> for &'a Var<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 2]; 2]>>> for Var<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 2]; 2]>>> for &'a Var<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 3]; 3]>>> for Var<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 3]; 3]>>> for &'a Var<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 3]; 3]>>> for Var<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 3]; 3]>>> for &'a Var<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 4]; 4]>>> for Var<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 4]; 4]>>> for &'a Var<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 4]; 4]>>> for Var<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 4]; 4]>>> for &'a Var<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<f32>>> for Var<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<f32>>> for &'a Var<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<f32>>> for Var<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<f32>>> for &'a Var<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<f32>>> for Var<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<f32>>> for &'a Var<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 2]; 2]>> for Var<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: M22) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 2]; 2]>> for &'a Var<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: M22) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 2]; 2]>> for Var<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: M22) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 2]; 2]>> for &'a Var<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: M22) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 3]; 3]>> for Var<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: M33) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 3]; 3]>> for &'a Var<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: M33) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 3]; 3]>> for Var<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: M33) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 3]; 3]>> for &'a Var<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: M33) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 4]; 4]>> for Var<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: M44) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 4]; 4]>> for &'a Var<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: M44) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 4]; 4]>> for Var<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: M44) -> Self::Output

Performs the * operation.

impl<'a> Mul<Matrix<[[f32; 4]; 4]>> for &'a Var<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: M44) -> Self::Output

Performs the * operation.

impl<'a> Mul<V2<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V2<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V2<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V2<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V2<f32>> for Var<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V2<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V2<f32>> for &'a Var<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V2<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V2<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V2<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V2<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V2<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V2<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V2<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V2<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V2<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V3<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V3<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V3<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V3<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V3<f32>> for Var<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V3<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V3<f32>> for &'a Var<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V3<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V3<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V3<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V3<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V3<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V3<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V3<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V3<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V3<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V4<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V4<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V4<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V4<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V4<f32>> for Var<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V4<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V4<f32>> for &'a Var<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V4<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V4<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V4<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V4<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V4<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V4<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V4<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<V4<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: V4<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 2]; 2]>>> for Expr<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 2]; 2]>>> for Var<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 2]; 2]>>> for &'a Expr<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 2]; 2]>>> for &'a Var<M22>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 2]; 2]>>> for Expr<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 2]; 2]>>> for Var<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 2]; 2]>>> for &'a Expr<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 2]; 2]>>> for &'a Var<V2<f32>>

type Output = Expr<M22>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 3]; 3]>>> for Expr<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 3]; 3]>>> for Var<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 3]; 3]>>> for &'a Expr<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 3]; 3]>>> for &'a Var<M33>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 3]; 3]>>> for Expr<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 3]; 3]>>> for Var<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 3]; 3]>>> for &'a Expr<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 3]; 3]>>> for &'a Var<V3<f32>>

type Output = Expr<M33>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 4]; 4]>>> for Expr<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 4]; 4]>>> for Var<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 4]; 4]>>> for &'a Expr<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 4]; 4]>>> for &'a Var<M44>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 4]; 4]>>> for Expr<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 4]; 4]>>> for Var<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 4]; 4]>>> for &'a Expr<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<Matrix<[[f32; 4]; 4]>>> for &'a Var<V4<f32>>

type Output = Expr<M44>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<f32>>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<f32>>> for Expr<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<f32>>> for Var<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<f32>>> for &'a Expr<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<f32>>> for &'a Var<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<i32>>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<u32>>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<f32>>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<f32>>> for Expr<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<f32>>> for Var<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<f32>>> for &'a Expr<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<f32>>> for &'a Var<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<i32>>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<u32>>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<f32>>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<f32>>> for Expr<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<f32>>> for Var<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<f32>>> for &'a Expr<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<f32>>> for &'a Var<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<i32>>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<u32>>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Var<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Var<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<f32> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<f32> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<f32> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<f32> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<f32> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<f32> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<f32> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<f32> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<i32> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<i32> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<i32> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<i32> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<i32> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<i32> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<i32> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<i32> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<u32> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<'a> Mul<u32> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<'a> Mul<u32> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<'a> Mul<u32> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<'a> Mul<u32> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<'a> Mul<u32> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<'a> Mul<u32> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<'a> Mul<u32> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<'a> Rem<&'a Expr<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Expr<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V2<f32>>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V3<f32>>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V4<f32>>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a Var<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<V2<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: V2<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<V2<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: V2<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<V3<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: V3<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<V3<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: V3<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<V4<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: V4<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<V4<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: V4<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V2<f32>>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V3<f32>>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V4<f32>>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Var<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Var<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<f32> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<'a> Rem<f32> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<'a> Rem<f32> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<'a> Rem<f32> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<'a> Rem<f32> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<'a> Rem<f32> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<'a> Rem<f32> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<'a> Rem<f32> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<'a> Sub<&'a Expr<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Expr<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<f32>>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<i32>>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<u32>>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<f32>>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<i32>>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<u32>>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<f32>>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<i32>>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<u32>>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Var<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V2<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V2<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V2<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V2<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V2<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V2<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V2<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V2<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V2<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V2<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V2<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V2<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V3<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V3<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V3<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V3<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V3<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V3<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V3<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V3<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V3<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V3<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V3<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V3<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V4<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V4<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V4<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V4<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V4<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V4<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V4<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V4<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V4<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V4<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<V4<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: V4<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<f32>>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<f32>>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<f32>>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<i32>>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<i32>>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<i32>>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<u32>>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<u32>>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V2<u32>>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<f32>>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<f32>>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<f32>>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<i32>>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<i32>>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<i32>>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<u32>>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<u32>>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V3<u32>>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<f32>>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<f32>>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<f32>>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<i32>>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<i32>>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<i32>>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<u32>>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<u32>>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<V4<u32>>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<f32>> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<i32>> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Var<u32>> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Var<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<f32> for Var<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<f32> for &'a Var<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<f32> for Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<f32> for &'a Var<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<f32> for Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<f32> for &'a Var<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<f32> for Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<f32> for &'a Var<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<i32> for Var<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<i32> for &'a Var<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<i32> for Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<i32> for &'a Var<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<i32> for Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<i32> for &'a Var<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<i32> for Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<i32> for &'a Var<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<u32> for Var<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<u32> for &'a Var<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<u32> for Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<u32> for &'a Var<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<u32> for Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<u32> for &'a Var<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<u32> for Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<u32> for &'a Var<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.