Enum ExprKind

pub enum ExprKind {
    Entity {
        id: EntityIndex,
    },
    LineLineIntersection {
        k: VarIndex,
        l: VarIndex,
    },
    AveragePoint {
        items: Vec<VarIndex>,
    },
    CircleCenter {
        circle: VarIndex,
    },
    Sum {
        plus: Vec<VarIndex>,
        minus: Vec<VarIndex>,
    },
    Product {
        times: Vec<VarIndex>,
        by: Vec<VarIndex>,
    },
    Const {
        value: ProcNum,
    },
    PartialPower {
        value: VarIndex,
        exponent: CompExponent,
    },
    PointPointDistance {
        p: VarIndex,
        q: VarIndex,
    },
    PointLineDistance {
        point: VarIndex,
        line: VarIndex,
    },
    ThreePointAngle {
        p: VarIndex,
        q: VarIndex,
        r: VarIndex,
    },
    ThreePointAngleDir {
        p: VarIndex,
        q: VarIndex,
        r: VarIndex,
    },
    TwoLineAngle {
        k: VarIndex,
        l: VarIndex,
    },
    PointX {
        point: VarIndex,
    },
    PointY {
        point: VarIndex,
    },
    PointPoint {
        p: VarIndex,
        q: VarIndex,
    },
    AngleBisector {
        p: VarIndex,
        q: VarIndex,
        r: VarIndex,
    },
    ParallelThrough {
        point: VarIndex,
        line: VarIndex,
    },
    PerpendicularThrough {
        point: VarIndex,
        line: VarIndex,
    },
    ConstructCircle {
        center: VarIndex,
        radius: VarIndex,
    },
}

A mathematical expression with a flattened memory model.

Variants

Entity

An entity referece.

Fields

id: EntityIndex

LineLineIntersection

An intersection of two lines: k and l

Fields

k: VarIndex

l: VarIndex

AveragePoint

The arithmetic mean of given point expressions

Fields

items: Vec<VarIndex>

CircleCenter

Center of a circle.

Fields

circle: VarIndex

Sum

Sum of numbers.

A normalized sum must be sorted and must not contain other sums or negations. An aggregated constant, if any, must be at the end.

Fields

plus: Vec<VarIndex>

Items to add.

minus: Vec<VarIndex>

Items to subtract.

Product

Product of numbers.

A normalized product must be sorted and must not contain other products. An aggregated constant, if any, must be at the end.

Fields

times: Vec<VarIndex>

Items to multiply by.

by: Vec<VarIndex>

Items to divide by.

Const

A constant.

Fields

value: ProcNum

PartialPower

Raising a value to a power. Raises both parts of the number (real and imaginary) to the same power. This is NOT equivalent to exponentiating a complex.

Fields

value: VarIndex

exponent: CompExponent

PointPointDistance

A distance between two points.

Fields

p: VarIndex

q: VarIndex

PointLineDistance

A distance of a point from a line.

Fields

point: VarIndex

line: VarIndex

ThreePointAngle

An angle defined by three points (arm, origin, arm)

Fields

p: VarIndex

Angle’s one arm.

q: VarIndex

Angle’s origin

r: VarIndex

Angle’s other arm

ThreePointAngleDir

A directed angle defined by three points (arm, origin, arm)

Fields

p: VarIndex

Angle’s first arm.

q: VarIndex

Angle’s origin.

r: VarIndex

Angle’s second arm.

TwoLineAngle

The angle described by two lines.

Fields

k: VarIndex

l: VarIndex

PointX

The real part of a point.

Fields

point: VarIndex

PointY

The imaginary part of a point.

Fields

point: VarIndex

PointPoint

A line through two points.

Fields

p: VarIndex

q: VarIndex

AngleBisector

The angle bisector line.

Fields

p: VarIndex

q: VarIndex

r: VarIndex

ParallelThrough

A line parallel to another line going through a point

Fields

point: VarIndex

line: VarIndex

PerpendicularThrough

A line perpendicular to another line going through a point

Fields

point: VarIndex

line: VarIndex

ConstructCircle

A circle constructed from its center and radius.

Fields

center: VarIndex

radius: VarIndex

Implementations

impl ExprKind

pub fn variant_id(&self) -> usize

Get the id of a variant. Used for comparison

pub fn compare(&self, other: &Self, math: &Math) -> Ordering

Compare two expressions.

pub fn get_type<M>( &self, expressions: &[Expr<M>], entities: &[Entity<M>], ) -> ExprType

Get the expression’s type.

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> ExprKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExprKind

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

Formats the value using the given formatter.

impl DeepClone for ExprKind

fn deep_clone(&self, arg0: &mut Math) -> Self

Perform a deep clone.

impl Default for ExprKind

fn default() -> Self

Returns the “default value” for a type.

impl From<ExprKind> for ExpressionKind

fn from(value: ExprKind) -> Self

Converts to this type from the input type.

impl FromUnrolled<Circle> for ExprKind

fn load(expr: &Unrolled<UnrolledCircle>, math: &mut Expand) -> Self

Load the unroll expression

impl FromUnrolled<Line> for ExprKind

fn load(expr: &Unrolled<UnrolledLine>, math: &mut Expand) -> Self

Load the unroll expression

impl FromUnrolled<Point> for ExprKind

fn load(expr: &Unrolled<UnrolledPoint>, math: &mut Expand) -> Self

Load the unroll expression

impl FromUnrolled<Scalar> for ExprKind

fn load(expr: &Unrolled<Scalar>, math: &mut Expand) -> Self

Load the unroll expression

impl Hash for ExprKind

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 Ord for ExprKind

fn cmp(&self, other: &ExprKind) -> 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 PartialEq for ExprKind

fn eq(&self, other: &ExprKind) -> 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 PartialOrd for ExprKind

fn partial_cmp(&self, other: &ExprKind) -> 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 Reconstruct for ExprKind

fn reconstruct(self, arg0: &mut ReconstructCtx<'_>) -> Self

Reconstruct the value.

impl Reindex for ExprKind

fn reindex(&mut self, arg0: &IndexMap)

Reindex the expression/rule according to the given map.

impl Serialize for ExprKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ExprKind

impl StructuralPartialEq for ExprKind