Struct QFlag 

pub struct QFlag<N, F: Flag> {
    pub basis: Basis<F>,
    pub data: Array1<N>,
    pub scale: u64,
    pub expr: Expr<N, F>,
}

An element of a flag algebra.

Fields

basis: Basis<F>

Basis of the space where the element lives. This corresponds to the size and type of the flags.

data: Array1<N>

The vector of the element in the corresponding basis is (1/self.scale).self.data.

scale: u64

Scaling factor of the vector.

expr: Expr<N, F>

Expression recording how the vector was computed.

Implementations

impl<N, F: Flag> QFlag<N, F>

pub fn expand(&self, outbasis: Basis<F>) -> Self

where N: Num + Clone + FromPrimitive,

Projection to a basis of larger flag.

pub fn untype(&self) -> Self

where N: Num + Clone + FromPrimitive,

Unlabeling operator 〚.〛 to the flag algebra of completly unlabeled flags.

pub fn with_expr(self, expr: Expr<N, F>) -> Self

Return the same element with modified pretty-print expression

pub fn named(self, name: String) -> Self

Name the vector for the purpose of pretty-printing

pub fn no_scale(self) -> Self

where N: FromPrimitive + DivAssign<N> + ScalarOperand,

Divide the elements of the vector by the scale and set the scale to 1

pub fn map<G, M>(&self, g: G) -> QFlag<M, F>

where G: Fn(&N) -> M,

impl<N, F> QFlag<N, F>

where N: Num + FromPrimitive + Clone + Display, F: Flag,

Creating inequalies from QFlag

pub fn at_least(&self, x: N) -> Ineq<N, F>

Return the inequality “self ≥ x”.

pub fn at_most(&self, x: N) -> Ineq<N, F>

where N: Clone + Neg<Output = N>,

Return the inequality “self ≤ x”.

pub fn non_negative(&self) -> Ineq<N, F>

where N: Num,

Return the inequality “self ≥ 0”.

pub fn equal(self, n: N) -> Ineq<N, F>

where N: Clone + Neg<Output = N>,

Return the equality “self = n”.

Trait Implementations

impl<N, F> Add<&QFlag<N, F>> for QFlag<N, F>

where N: Clone + FromPrimitive + Num + ScalarOperand, F: Flag,

type Output = QFlag<N, F>

The resulting type after applying the + operator.

fn add(self, other: &Self) -> Self::Output

Performs the + operation.

impl<N, F> Add for QFlag<N, F>

where N: Clone + Num + FromPrimitive + ScalarOperand, F: Flag,

type Output = QFlag<N, F>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<N: Clone, F: Clone + Flag> Clone for QFlag<N, F>

fn clone(&self) -> QFlag<N, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug, F: Debug + Flag> Debug for QFlag<N, F>

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

Formats the value using the given formatter.

impl<F, N> Html for QFlag<N, F>

where F: Flag + Draw, N: Num + Clone + Display + FromPrimitive,

const LATEX: bool = false

fn print_html<W: Write>(&self, w: &mut W) -> Result<()>

fn html(&self, name: &str) -> Result<()>

True if Mathjax need to be loaded

impl<N, F> Mul<N> for QFlag<N, F>

where N: Num + ScalarOperand + Display, F: Flag,

type Output = QFlag<N, F>

The resulting type after applying the * operator.

fn mul(self, rhs: N) -> Self::Output

Performs the * operation.

impl<'a, N, F> Mul for &'a QFlag<N, F>

where N: Num + Clone + FromPrimitive, F: Flag,

Flag algebra operations

type Output = QFlag<N, F>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> QFlag<N, F>

Performs the * operation.

impl<N, F> Mul for QFlag<N, F>

where N: Num + Clone + FromPrimitive, F: Flag,

type Output = QFlag<N, F>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl<'a, N, F> Neg for &'a QFlag<N, F>

where N: Clone + Neg<Output = N>, F: Flag,

type Output = QFlag<N, F>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<N, F: Flag> Neg for QFlag<N, F>

where N: Clone + Neg<Output = N>,

type Output = QFlag<N, F>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<N, F> PartialEq for QFlag<N, F>

where N: Num + FromPrimitive + Clone, F: Flag,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N, F> Pow<usize> for &QFlag<N, F>

where N: Num + Clone + FromPrimitive + Display, F: Flag,

type Output = QFlag<N, F>

The result after applying the operator.

fn pow(self, n: usize) -> QFlag<N, F>

Returns self to the power rhs.

impl<'a, N, F> Sub for &'a QFlag<N, F>

where N: Clone + Num + FromPrimitive + ScalarOperand, F: Flag,

type Output = QFlag<N, F>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<N, F> Sub for QFlag<N, F>

where N: Clone + Num + FromPrimitive + ScalarOperand, F: Flag,

type Output = QFlag<N, F>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.