Struct Basis 

pub struct Basis<F: Flag> {
    pub size: usize,
    pub t: Type<F>,
}

Identifier for the set of flags with given size and type (in the sense of a labeled subgraph).

The kind of flag is determined by the associated Rust datatype. For instance Basis<Graph> is the Rust type for a basis of graphs.

basis.get() returns an ordered vector containing all corresponding flags.

Fields

size: usize

Number of vertices in the flags of the basis.

t: Type<F>

Type of the flags of the basis.

Implementations

impl<F: Flag> Basis<F>

Defining a Basis

pub fn new(size: usize) -> Self

Basis of flag with size vertices and without type.

 use flag_algebra::*;
 use flag_algebra::flags::Graph;

 // Set of graphs of size 3
 // (the kind of flag -Graph- is deduced by type inference)
 let basis = Basis::new(3);
 let size_3_graphs: Vec<Graph> = basis.get();
 assert_eq!(size_3_graphs.len(), 4);

 // With explicit type annotation
 let same_basis: Basis<Graph> = Basis::new(3);

pub fn with_type(self, t: Type<F>) -> Self

Basis of flag with same size as self and type t.

 use flag_algebra::*;
 use flag_algebra::flags::Graph;

 // Basis of graphs of size 4 rooted on an edge
 let edge = Graph::new(2, &[(0, 1)]);
 let t = Type::from_flag(&edge);
 let basis: Basis<Graph> = Basis::new(4).with_type(t);

pub fn without_type(self) -> Self

Basis of flag with same size as self without type t.

pub fn with_size(self, size: usize) -> Self

Basis of flag with size vertices and same type as self.

pub fn print_concise(self) -> String

Print the basis information in a short way.

impl<F: Flag> Basis<F>

Defining a quantum flags from a specified basis.

pub fn one<N>(self) -> QFlag<N, F>

where N: Num + Clone,

Sum of all flags of the basis. This is an expression of the 1 of the flag algebra.

use flag_algebra::*;
use flag_algebra::flags::Graph;

let b = Basis::new(2);
let one = b.one();
let other: QFlag<i64, Graph> = b.random();
assert_eq!(&one * &other, other.expand(Basis::new(4)));

pub fn zero<N>(self) -> QFlag<N, F>

where N: Num + Clone,

The zero vector in the specified basis.

use flag_algebra::*;
use flag_algebra::flags::Graph;

let basis = Basis::new(3);
let x: QFlag<i64, Graph> = basis.random();
assert_eq!(basis.zero() + &x, x);

pub fn qflag_from_indicator<N, P>(self, predicate: P) -> QFlag<N, F>

where P: Fn(&F, usize) -> bool + 'static, N: One + Zero,

Return the formal sum of the flags of the basis self that satisfies some predicate f.

The predicate f takes two arguments g and sigma, where g is a reference to the flag and sigma is the size of the labeled part.

use flag_algebra::*;
use flag_algebra::flags::Graph;

// Sum of graphs of size 3 with an even number of edges
let b = Basis::<Graph>::new(3);
let sum = b.qflag_from_indicator(|g, _| g.edges().count() % 2 == 0 );

let e3: QFlag<f64, Graph> = flag(&Graph::new(3, &[]));
let p3 = flag(&Graph::new(3, &[(0, 1), (1, 2)]));
assert_eq!(sum, e3 + &p3);

/// Sum of the graphs of size 3 rooted on one vertex v
/// where v has degree at least 1
let t: Type<Graph> = Type::from_flag(&Graph::new(1, &[])); // Type for one vertex
let basis = Basis::new(3).with_type(t);
let sum: QFlag<f64, Graph> = basis.qflag_from_indicator(move |g, _| g.edge(0, 1) || g.edge(0, 2) );

pub fn qflag_from_coeff<N, M, P>(self, f: P) -> QFlag<N, F>

where P: Fn(&F, usize) -> M + 'static, M: Into<N>,

Return the formal sum of f(g)*g on the flags g of the basis self. The second parameter of f is the size of the type of g.

use flag_algebra::*;
use flag_algebra::flags::Graph;

// Sum of graphs of size 3 weighted by their number of edges
let b = Basis::<Graph>::new(3);
let sum: QFlag<f64, Graph>  = b.qflag_from_coeff(|g, _| g.edges().count() as f64 );

pub fn random<N>(self) -> QFlag<N, F>

where N: From<i16>,

pub fn flag<N>(self, f: &F) -> QFlag<N, F>

where N: Num + Clone,

Create a quantum flag containing exactly one flag.

pub fn all_cs(&self) -> Vec<MulAndUnlabel<F>>

Returns the list of identifiers of all Square-and-unlabel operators that can be used in Cauchy-Schwarz inequalities for a problem on the basis self.

Trait Implementations

impl<F: Clone + Flag> Clone for Basis<F>

fn clone(&self) -> Basis<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Flag> Debug for Basis<F>

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

Formats the value using the given formatter.

impl<F: Flag> Display for Basis<F>

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

Formats the value using the given formatter.

impl<F: Flag> Div for Basis<F>

type Output = Basis<F>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs the / operation.

impl<F: Hash + Flag> Hash for Basis<F>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F> Html for Basis<F>

where F: Flag + Draw,

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<F: Flag> Mul for Basis<F>

type Output = Basis<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Ord + Flag> Ord for Basis<F>

fn cmp(&self, other: &Basis<F>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<F: PartialEq + Flag> PartialEq for Basis<F>

fn eq(&self, other: &Basis<F>) -> 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<F: PartialOrd + Flag> PartialOrd for Basis<F>

fn partial_cmp(&self, other: &Basis<F>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<F: Flag> Savable<Vec<F>, F> for Basis<F>

fn filename(&self) -> String

Name of the file where the operator can be saved.

fn create(&self) -> Vec<F>

Compute the object.

fn file_path(&self) -> PathBuf

Path to the corresponding file.

fn create_and_save(&self, path: &Path) -> A

(Re)create the object, save it in the corresponding file and return it.

fn load(&self, path: &Path) -> Result<A, Box<dyn Error>>

Load the object if the file exists and is valid.

fn get(&self) -> A

Function to automatically load the object if the file exists and is valid, or create and save it otherwise.

impl<F: Flag> Copy for Basis<F>

impl<F: Eq + Flag> Eq for Basis<F>

impl<F: Flag> StructuralPartialEq for Basis<F>