Struct shades::Expr

pub struct Expr<T> where
    T: ?Sized,  { /* fields omitted */ }

Expression representation.

An expression is anything that carries a (typed) value and that can be combined in various ways with other expressions. A literal, a constant or a variable are all expressions. The sum (as in a + b) of two expressions is also an expression. A function call returning an expression is also an expression, as in a * sin(b). Accessing an element in an array (which is an expression as it carries items) via an index (an expression) is also an expression — e.g. levels[y * HEIGHT + x] * size. The same thing applies to field access, swizzling, etc. etc.

On a general note, expressions are pretty central to the EDSL, as they are the lower level concept you will be able to manipulate. Expressions are side effect free, so a variable, for instance, can either be considered as an expression or not. If x is a variable (see Var), then x * 10 is an expression, but using x to mutate its content does not make a use of x as an expression. It means that expressions are read-only and even though you can go from higher constructs (like variables) to expressions, the opposite direction is forbidden.

Literals

The most obvious kind of expression is a literal — e.g. 1, false, 3.14, etc. Any type T that defines an implementor From<T> for Expr<T> can be used as literal. You can then use, for instance, 1.into(), Expr::from(1), etc.

A much better and easier way to create literals is to use the lit! macro, which basically does the lifting for you, but also accept more forms to create more complex literals, such as scalar vectors. See its documentation for further details.

It’s important to notice that because of how Rust infers type, type ambiguities might occur when using literals — hence, the use of lit! should help. For instance, in 1 + 2, the type of 1 is ambiguous because of how the implementors for Add are picked. In such a case, you are advised to use lit!.

Automatic lifting

Sometimes, you will want to pass literals to form other expressions, function calls, etc. Most of the API has been written in a way that if no ambiguity would occur, then you can use the Rust type directly. For instance, if x has the type Expr<i32>, then x + 1 is the same as x + lit!(1). You can use this property with literals too: lit!(1) + 2 + 3 + 4.

That automatic lifting is valid for a lot of traits and methods throughout this crate.

Expressions from side-effects

Some side-effects will create expressions, such as creating a variable or a constant. Most of the time, you shouldn’t have to worry about the type of the expression as it should be inferred based on the side-effect.

Expression macros

Some macros will create expressions for you, such as lit!, vec2!, vec3! and vec4! or the sw! macros. Most of the time, those macros will work by automatically adding a reference (&) to their arguments so that you don’t have to worry about that either.

Implementations

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

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.)

impl<T> Expr<T> where
    T: PartialOrd, 

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;

impl Expr<bool>

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

impl<T> Expr<[T]>

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]

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

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]

impl Expr<TessControlPerVertexIn>

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]>

impl Expr<TessControlPerVertexOut>

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.

impl Expr<TessEvaluationPerVertexIn>

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.

impl Expr<GeometryPerVertexIn>

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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<f32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<i32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<i32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<u32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<u32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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 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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<Expr<V2<f32>>> for Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<f32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<i32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<i32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<u32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<Expr<u32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<V2<f32>> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<f32> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<bool>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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 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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<Expr<V2<bool>>> for Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<Expr<bool>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<V2<bool>> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<bool> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<bool>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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 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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<Expr<V2<bool>>> for Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<Expr<bool>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<V2<bool>> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<bool> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<bool>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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 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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<Expr<V2<bool>>> for Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<Expr<bool>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<V2<bool>> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<bool> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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> Clone for Expr<T> where
    T: ?Sized, 

fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Expr<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Div<&'a Expr<V2<f32>>> for Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<f32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<i32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<i32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<u32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<u32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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 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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<Expr<V2<f32>>> for Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<f32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<i32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<i32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<u32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<Expr<u32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<V2<f32>> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<f32> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Exponential for Expr<f32>

fn pow(&self, p: impl Into<Self>) -> Self

fn exp(&self) -> Self

fn exp2(&self) -> Self

fn log(&self) -> Self

fn log2(&self) -> Self

fn sqrt(&self) -> Self

fn isqrt(&self) -> Self

impl Exponential for Expr<V2<f32>>

fn pow(&self, p: impl Into<Self>) -> Self

fn exp(&self) -> Self

fn exp2(&self) -> Self

fn log(&self) -> Self

fn log2(&self) -> Self

fn sqrt(&self) -> Self

fn isqrt(&self) -> Self

impl Exponential for Expr<V3<f32>>

fn pow(&self, p: impl Into<Self>) -> Self

fn exp(&self) -> Self

fn exp2(&self) -> Self

fn log(&self) -> Self

fn log2(&self) -> Self

fn sqrt(&self) -> Self

fn isqrt(&self) -> Self

impl Exponential for Expr<V4<f32>>

fn pow(&self, p: impl Into<Self>) -> Self

fn exp(&self) -> Self

fn exp2(&self) -> Self

fn log(&self) -> Self

fn log2(&self) -> Self

fn sqrt(&self) -> Self

fn isqrt(&self) -> Self

impl Floating for Expr<f32>

fn floor(&self) -> Self

fn trunc(&self) -> Self

fn round(&self) -> Self

fn ceil(&self) -> Self

fn fract(&self) -> Self

impl Floating for Expr<V2<f32>>

fn floor(&self) -> Self

fn trunc(&self) -> Self

fn round(&self) -> Self

fn ceil(&self) -> Self

fn fract(&self) -> Self

impl Floating for Expr<V3<f32>>

fn floor(&self) -> Self

fn trunc(&self) -> Self

fn round(&self) -> Self

fn ceil(&self) -> Self

fn fract(&self) -> Self

impl Floating for Expr<V4<f32>>

fn floor(&self) -> Self

fn trunc(&self) -> Self

fn round(&self) -> Self

fn ceil(&self) -> Self

fn fract(&self) -> Self

impl FloatingExt for Expr<f32>

type BoolExpr = Expr<bool>

fn is_nan(&self) -> Self::BoolExpr

fn is_inf(&self) -> Self::BoolExpr

impl FloatingExt for Expr<V2<f32>>

type BoolExpr = Expr<V2<bool>>

fn is_nan(&self) -> Self::BoolExpr

fn is_inf(&self) -> Self::BoolExpr

impl FloatingExt for Expr<V3<f32>>

type BoolExpr = Expr<V3<bool>>

fn is_nan(&self) -> Self::BoolExpr

fn is_inf(&self) -> Self::BoolExpr

impl FloatingExt for Expr<V4<f32>>

type BoolExpr = Expr<V4<bool>>

fn is_nan(&self) -> Self::BoolExpr

fn is_inf(&self) -> Self::BoolExpr

impl<T> From<&'_ Expr<T>> for Expr<T> where
    T: ?Sized, 

fn from(e: &Self) -> Self

Performs the conversion.

impl<'a, T, const N: usize> From<&'a [Expr<T>; N]> for Expr<[T; N]> where
    Expr<T>: From<T>,
    T: ToType, 

fn from(array: &'a [Expr<T>; N]) -> Self

Performs the conversion.

impl<'a, T, const N: usize> From<&'a [T; N]> for Expr<[T; N]> where
    Expr<T>: From<T>,
    T: Clone + ToType, 

fn from(array: &'a [T; N]) -> Self

Performs the conversion.

impl<'a> From<&'a V2<bool>> for Expr<V2<bool>>

fn from(a: &'a V2<bool>) -> Self

Performs the conversion.

impl<'a> From<&'a V2<f32>> for Expr<V2<f32>>

fn from(a: &'a V2<f32>) -> Self

Performs the conversion.

impl<'a> From<&'a V2<i32>> for Expr<V2<i32>>

fn from(a: &'a V2<i32>) -> Self

Performs the conversion.

impl<'a> From<&'a V2<u32>> for Expr<V2<u32>>

fn from(a: &'a V2<u32>) -> Self

Performs the conversion.

impl<'a> From<&'a V3<bool>> for Expr<V3<bool>>

fn from(a: &'a V3<bool>) -> Self

Performs the conversion.

impl<'a> From<&'a V3<f32>> for Expr<V3<f32>>

fn from(a: &'a V3<f32>) -> Self

Performs the conversion.

impl<'a> From<&'a V3<i32>> for Expr<V3<i32>>

fn from(a: &'a V3<i32>) -> Self

Performs the conversion.

impl<'a> From<&'a V3<u32>> for Expr<V3<u32>>

fn from(a: &'a V3<u32>) -> Self

Performs the conversion.

impl<'a> From<&'a V4<bool>> for Expr<V4<bool>>

fn from(a: &'a V4<bool>) -> Self

Performs the conversion.

impl<'a> From<&'a V4<f32>> for Expr<V4<f32>>

fn from(a: &'a V4<f32>) -> Self

Performs the conversion.

impl<'a> From<&'a V4<i32>> for Expr<V4<i32>>

fn from(a: &'a V4<i32>) -> Self

Performs the conversion.

impl<'a> From<&'a V4<u32>> for Expr<V4<u32>>

fn from(a: &'a V4<u32>) -> 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<'a> From<&'a bool> for Expr<bool>

fn from(a: &'a bool) -> Self

Performs the conversion.

impl<'a> From<&'a f32> for Expr<f32>

fn from(a: &'a f32) -> Self

Performs the conversion.

impl<'a> From<&'a i32> for Expr<i32>

fn from(a: &'a i32) -> Self

Performs the conversion.

impl<'a> From<&'a u32> for Expr<u32>

fn from(a: &'a u32) -> Self

Performs the conversion.

impl<T, const N: usize> From<[Expr<T>; N]> for Expr<[T; N]> where
    Expr<T>: From<T>,
    T: ToType, 

fn from(array: [Expr<T>; N]) -> Self

Performs the conversion.

impl<T, const N: usize> From<[T; N]> for Expr<[T; N]> where
    Expr<T>: From<T>,
    T: Clone + ToType, 

fn from(array: [T; N]) -> Self

Performs the conversion.

impl<T> From<Expr<T>> for Return where
    T: ToType, 

fn from(expr: Expr<T>) -> Self

Performs the conversion.

impl From<Matrix<[[f32; 2]; 2]>> for Expr<Matrix<[[f32; 2]; 2]>>

fn from(matrix: Matrix<[[f32; 2]; 2]>) -> Self

Performs the conversion.

impl From<Matrix<[[f32; 3]; 3]>> for Expr<Matrix<[[f32; 3]; 3]>>

fn from(matrix: Matrix<[[f32; 3]; 3]>) -> Self

Performs the conversion.

impl From<Matrix<[[f32; 4]; 4]>> for Expr<Matrix<[[f32; 4]; 4]>>

fn from(matrix: Matrix<[[f32; 4]; 4]>) -> Self

Performs the conversion.

impl From<V2<bool>> for Expr<V2<bool>>

fn from(a: V2<bool>) -> Self

Performs the conversion.

impl From<V2<f32>> for Expr<V2<f32>>

fn from(a: V2<f32>) -> Self

Performs the conversion.

impl From<V2<i32>> for Expr<V2<i32>>

fn from(a: V2<i32>) -> Self

Performs the conversion.

impl From<V2<u32>> for Expr<V2<u32>>

fn from(a: V2<u32>) -> Self

Performs the conversion.

impl From<V3<bool>> for Expr<V3<bool>>

fn from(a: V3<bool>) -> Self

Performs the conversion.

impl From<V3<f32>> for Expr<V3<f32>>

fn from(a: V3<f32>) -> Self

Performs the conversion.

impl From<V3<i32>> for Expr<V3<i32>>

fn from(a: V3<i32>) -> Self

Performs the conversion.

impl From<V3<u32>> for Expr<V3<u32>>

fn from(a: V3<u32>) -> Self

Performs the conversion.

impl From<V4<bool>> for Expr<V4<bool>>

fn from(a: V4<bool>) -> Self

Performs the conversion.

impl From<V4<f32>> for Expr<V4<f32>>

fn from(a: V4<f32>) -> Self

Performs the conversion.

impl From<V4<i32>> for Expr<V4<i32>>

fn from(a: V4<i32>) -> Self

Performs the conversion.

impl From<V4<u32>> for Expr<V4<u32>>

fn from(a: V4<u32>) -> 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 From<bool> for Expr<bool>

fn from(a: bool) -> Self

Performs the conversion.

impl From<f32> for Expr<f32>

fn from(a: f32) -> Self

Performs the conversion.

impl From<i32> for Expr<i32>

fn from(a: i32) -> Self

Performs the conversion.

impl From<u32> for Expr<u32>

fn from(a: u32) -> Self

Performs the conversion.

impl Geometry for Expr<V2<f32>>

type LengthExpr = Expr<f32>

fn length(&self) -> Self::LengthExpr

fn distance(&self, other: impl Into<Self>) -> Self::LengthExpr

fn dot(&self, other: impl Into<Self>) -> Self::LengthExpr

fn cross(&self, other: impl Into<Self>) -> Self

fn normalize(&self) -> Self

fn face_forward(
    &self,
    normal: impl Into<Self>,
    reference: impl Into<Self>
) -> Self

fn reflect(&self, normal: impl Into<Self>) -> Self

fn refract(&self, normal: impl Into<Self>, eta: impl Into<Expr<f32>>) -> Self

impl Geometry for Expr<V3<f32>>

type LengthExpr = Expr<f32>

fn length(&self) -> Self::LengthExpr

fn distance(&self, other: impl Into<Self>) -> Self::LengthExpr

fn dot(&self, other: impl Into<Self>) -> Self::LengthExpr

fn cross(&self, other: impl Into<Self>) -> Self

fn normalize(&self) -> Self

fn face_forward(
    &self,
    normal: impl Into<Self>,
    reference: impl Into<Self>
) -> Self

fn reflect(&self, normal: impl Into<Self>) -> Self

fn refract(&self, normal: impl Into<Self>, eta: impl Into<Expr<f32>>) -> Self

impl Geometry for Expr<V4<f32>>

type LengthExpr = Expr<f32>

fn length(&self) -> Self::LengthExpr

fn distance(&self, other: impl Into<Self>) -> Self::LengthExpr

fn dot(&self, other: impl Into<Self>) -> Self::LengthExpr

fn cross(&self, other: impl Into<Self>) -> Self

fn normalize(&self) -> Self

fn face_forward(
    &self,
    normal: impl Into<Self>,
    reference: impl Into<Self>
) -> Self

fn reflect(&self, normal: impl Into<Self>) -> Self

fn refract(&self, normal: impl Into<Self>, eta: impl Into<Expr<f32>>) -> Self

impl Mix<Expr<V2<f32>>> for Expr<V2<f32>>

fn mix(&self, y: impl Into<Self>, a: Expr<V2<f32>>) -> Self

fn step(&self, edge: Expr<V2<f32>>) -> Self

fn smooth_step(&self, edge_a: Expr<V2<f32>>, edge_b: Expr<V2<f32>>) -> Self

impl Mix<Expr<V3<f32>>> for Expr<V3<f32>>

fn mix(&self, y: impl Into<Self>, a: Expr<V3<f32>>) -> Self

fn step(&self, edge: Expr<V3<f32>>) -> Self

fn smooth_step(&self, edge_a: Expr<V3<f32>>, edge_b: Expr<V3<f32>>) -> Self

impl Mix<Expr<V4<f32>>> for Expr<V4<f32>>

fn mix(&self, y: impl Into<Self>, a: Expr<V4<f32>>) -> Self

fn step(&self, edge: Expr<V4<f32>>) -> Self

fn smooth_step(&self, edge_a: Expr<V4<f32>>, edge_b: Expr<V4<f32>>) -> Self

impl Mix<Expr<f32>> for Expr<f32>

fn mix(&self, y: impl Into<Self>, a: Expr<f32>) -> Self

fn step(&self, edge: Expr<f32>) -> Self

fn smooth_step(&self, edge_a: Expr<f32>, edge_b: Expr<f32>) -> Self

impl Mix<Expr<f32>> for Expr<V2<f32>>

fn mix(&self, y: impl Into<Self>, a: Expr<f32>) -> Self

fn step(&self, edge: Expr<f32>) -> Self

fn smooth_step(&self, edge_a: Expr<f32>, edge_b: Expr<f32>) -> Self

impl Mix<Expr<f32>> for Expr<V3<f32>>

fn mix(&self, y: impl Into<Self>, a: Expr<f32>) -> Self

fn step(&self, edge: Expr<f32>) -> Self

fn smooth_step(&self, edge_a: Expr<f32>, edge_b: Expr<f32>) -> Self

impl Mix<Expr<f32>> for Expr<V4<f32>>

fn mix(&self, y: impl Into<Self>, a: Expr<f32>) -> Self

fn step(&self, edge: Expr<f32>) -> Self

fn smooth_step(&self, edge_a: Expr<f32>, edge_b: Expr<f32>) -> Self

impl<'a> Mul<&'a Expr<Matrix<[[f32; 2]; 2]>>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<f32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<i32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<i32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<u32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<u32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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 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 &'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 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 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; 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 &'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 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 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; 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 &'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 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 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<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 &'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 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 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<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 &'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<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 &'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<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 &'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 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 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<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 &'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<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 &'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<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 &'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 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 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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<Expr<Matrix<[[f32; 2]; 2]>>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<f32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<i32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<i32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<u32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<Expr<u32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<Matrix<[[f32; 2]; 2]>> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 &'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 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 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; 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 &'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 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 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; 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 &'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 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 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<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 &'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 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 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<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 &'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<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 &'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<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 &'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 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 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<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 &'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<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 &'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<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 &'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 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 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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<f32> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Neg for Expr<i32>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V2<u32>>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V3<u32>>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V4<u32>>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<f32>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V2<f32>>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V2<i32>>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V3<f32>>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V4<f32>>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V3<i32>>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V4<i32>>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<u32>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for Expr<bool>

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'a> Not for &'a Expr<bool>

type Output = Expr<bool>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for Expr<V2<bool>>

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'a> Not for &'a Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for Expr<V3<bool>>

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'a> Not for &'a Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for Expr<V4<bool>>

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'a> Not for &'a Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Relative for Expr<i32>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V2<i32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V3<i32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V4<i32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<f32>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V2<f32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V3<f32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V4<f32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl<'a> Rem<&'a Expr<V2<f32>>> for Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<f32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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 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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<Expr<V2<f32>>> for Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<Expr<f32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<V2<f32>> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<f32> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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> Shl<&'a Expr<u32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<&'a Expr<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<Expr<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<Expr<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<i32>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<V2<u32>>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<V3<u32>>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<V4<u32>>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<f32>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<V2<f32>>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<V2<i32>>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<V3<f32>>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<V4<f32>>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<V3<i32>>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<V4<i32>>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for Expr<u32>

type Output = Self

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shl<u32> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<&'a Expr<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<Expr<u32>> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<i32>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<i32>

type Output = Expr<i32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<V2<u32>>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<V3<u32>>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<V4<u32>>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<f32>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<f32>

type Output = Expr<f32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<V2<f32>>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<V2<i32>>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<V3<f32>>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<V4<f32>>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<V3<i32>>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<V4<i32>>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for Expr<u32>

type Output = Self

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Shr<u32> for &'a Expr<u32>

type Output = Expr<u32>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a> Sub<&'a Expr<V2<f32>>> for Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<f32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<i32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<i32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<u32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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 Expr<u32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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 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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<Expr<V2<f32>>> for Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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 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 Expr<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 Expr<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<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 Expr<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 Expr<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 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 Expr<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<f32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<i32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<i32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<u32>> for Expr<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<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 Expr<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 Expr<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 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 Expr<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<Expr<u32>> for &'a Expr<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 Expr<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<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 Expr<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 Expr<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<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<V2<f32>> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<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 &'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 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 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 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 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 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 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<f32> for Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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 Expr<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<T> Swizzlable<[SwizzleSelector; 2]> for Expr<V2<T>>

fn swizzle(&self, [x, y]: [SwizzleSelector; 2]) -> Self

impl<T> Swizzlable<[SwizzleSelector; 2]> for Expr<V3<T>>

fn swizzle(&self, [x, y]: [SwizzleSelector; 2]) -> Self

impl<T> Swizzlable<[SwizzleSelector; 2]> for Expr<V4<T>>

fn swizzle(&self, [x, y]: [SwizzleSelector; 2]) -> Self

impl<T> Swizzlable<[SwizzleSelector; 3]> for Expr<V3<T>>

fn swizzle(&self, [x, y, z]: [SwizzleSelector; 3]) -> Self

impl<T> Swizzlable<[SwizzleSelector; 3]> for Expr<V4<T>>

fn swizzle(&self, [x, y, z]: [SwizzleSelector; 3]) -> Self

impl<T> Swizzlable<[SwizzleSelector; 4]> for Expr<V4<T>>

fn swizzle(&self, [x, y, z, w]: [SwizzleSelector; 4]) -> Self

impl<T> Swizzlable<SwizzleSelector> for Expr<V2<T>>

fn swizzle(&self, x: SwizzleSelector) -> Self

impl<T> Swizzlable<SwizzleSelector> for Expr<V3<T>>

fn swizzle(&self, x: SwizzleSelector) -> Self

impl<T> Swizzlable<SwizzleSelector> for Expr<V4<T>>

fn swizzle(&self, x: SwizzleSelector) -> Self

impl<F, R, A> ToFun<R, Expr<A>> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A>) -> R,
    Return: From<R>,
    A: ToType, 

fn build_fn(self) -> FunDef<R, Expr<A>>

impl Trigonometry for Expr<f32>

fn radians(&self) -> Self

fn degrees(&self) -> Self

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn asin(&self) -> Self

fn acos(&self) -> Self

fn atan(&self) -> Self

fn sinh(&self) -> Self

fn cosh(&self) -> Self

fn tanh(&self) -> Self

fn asinh(&self) -> Self

fn acosh(&self) -> Self

fn atanh(&self) -> Self

impl Trigonometry for Expr<V2<f32>>

fn radians(&self) -> Self

fn degrees(&self) -> Self

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn asin(&self) -> Self

fn acos(&self) -> Self

fn atan(&self) -> Self

fn sinh(&self) -> Self

fn cosh(&self) -> Self

fn tanh(&self) -> Self

fn asinh(&self) -> Self

fn acosh(&self) -> Self

fn atanh(&self) -> Self

impl Trigonometry for Expr<V3<f32>>

fn radians(&self) -> Self

fn degrees(&self) -> Self

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn asin(&self) -> Self

fn acos(&self) -> Self

fn atan(&self) -> Self

fn sinh(&self) -> Self

fn cosh(&self) -> Self

fn tanh(&self) -> Self

fn asinh(&self) -> Self

fn acosh(&self) -> Self

fn atanh(&self) -> Self

impl Trigonometry for Expr<V4<f32>>

fn radians(&self) -> Self

fn degrees(&self) -> Self

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn asin(&self) -> Self

fn acos(&self) -> Self

fn atan(&self) -> Self

fn sinh(&self) -> Self

fn cosh(&self) -> Self

fn tanh(&self) -> Self

fn asinh(&self) -> Self

fn acosh(&self) -> Self

fn atanh(&self) -> Self

impl<T> Vec2<(Expr<T>, Expr<T>)> for Expr<V2<T>>

fn vec2(args: (Expr<T>, Expr<T>)) -> Self

Make a V2 from A.

impl<T> Vec3<(Expr<T>, Expr<T>, Expr<T>)> for Expr<V3<T>>

fn vec3(args: (Expr<T>, Expr<T>, Expr<T>)) -> Self

Make a V3 from A.

impl<T> Vec3<(Expr<V2<T>>, Expr<T>)> for Expr<V3<T>>

fn vec3(args: (Expr<V2<T>>, Expr<T>)) -> Self

Make a V3 from A.

impl<'a, T> Vec4<(Expr<T>, Expr<T>, Expr<T>, Expr<T>)> for Expr<V4<T>>

fn vec4(args: (Expr<T>, Expr<T>, Expr<T>, Expr<T>)) -> Self

Make a V4 from A.

impl<'a, T> Vec4<(Expr<V2<T>>, Expr<T>, Expr<T>)> for Expr<V4<T>>

fn vec4(args: (Expr<V2<T>>, Expr<T>, Expr<T>)) -> Self

Make a V4 from A.

impl<T> Vec4<(Expr<V2<T>>, Expr<V2<T>>)> for Expr<V4<T>>

fn vec4(args: (Expr<V2<T>>, Expr<V2<T>>)) -> Self

Make a V4 from A.

impl<T> Vec4<(Expr<V3<T>>, Expr<T>)> for Expr<V4<T>>

fn vec4(args: (Expr<V3<T>>, Expr<T>)) -> Self

Make a V4 from A.