Struct EquationElem

pub struct EquationElem {
    pub body: Content,
    /* private fields */
}

A mathematical equation.

Can be displayed inline with text or as a separate block. An equation becomes block-level through the presence of at least one space after the opening dollar sign and one space before the closing dollar sign.

Example

#set text(font: "New Computer Modern")

Let $a$, $b$, and $c$ be the side
lengths of right-angled triangle.
Then, we know that:
$ a^2 + b^2 = c^2 $

Prove by induction:
$ sum_(k=1)^n k = (n(n+1)) / 2 $

By default, block-level equations will not break across pages. This can be changed through {show math.equation: set block(breakable: true)}.

Syntax

This function also has dedicated syntax: Write mathematical markup within dollar signs to create an equation. Starting and ending the equation with at least one space lifts it into a separate block that is centered horizontally. For more details about math syntax, see the main math page.

Fields

body: Content

Implementations

impl EquationElem

pub fn new(body: Content) -> Self

Create a new instance of the element.

pub fn with_block(self, block: bool) -> Self

Builder-style setter for the block field.

pub fn with_numbering(self, numbering: Option<Numbering>) -> Self

Builder-style setter for the numbering field.

pub fn with_number_align( self, number_align: SpecificAlignment<OuterHAlignment, VAlignment>, ) -> Self

Builder-style setter for the number-align field.

pub fn with_supplement(self, supplement: Smart<Option<Supplement>>) -> Self

Builder-style setter for the supplement field.

pub fn push_block(&mut self, block: bool)

Setter for the block field.

pub fn push_numbering(&mut self, numbering: Option<Numbering>)

Setter for the numbering field.

pub fn push_number_align( &mut self, number_align: SpecificAlignment<OuterHAlignment, VAlignment>, )

Setter for the number-align field.

pub fn push_supplement(&mut self, supplement: Smart<Option<Supplement>>)

Setter for the supplement field.

pub fn block(&self, styles: StyleChain<'_>) -> bool

Whether the equation is displayed as a separate block.

pub fn numbering<'a>(&'a self, styles: StyleChain<'a>) -> &'a Option<Numbering>

How to number block-level equations.

#set math.equation(numbering: "(1)")

We define:
$ phi.alt := (1 + sqrt(5)) / 2 $ <ratio>

With @ratio, we get:
$ F_n = floor(1 / sqrt(5) phi.alt^n) $

pub fn number_align( &self, styles: StyleChain<'_>, ) -> SpecificAlignment<OuterHAlignment, VAlignment>

The alignment of the equation numbering.

By default, the alignment is {end + horizon}. For the horizontal component, you can use {right}, {left}, or {start} and {end} of the text direction; for the vertical component, you can use {top}, {horizon}, or {bottom}.

#set math.equation(numbering: "(1)", number-align: bottom)

We can calculate:
$ E &= sqrt(m_0^2 + p^2) \
    &approx 125 "GeV" $

pub fn supplement(&self, styles: StyleChain<'_>) -> Smart<Option<Supplement>>

A supplement for the equation.

For references to equations, this is added before the referenced number.

If a function is specified, it is passed the referenced equation and should return content.

#set math.equation(numbering: "(1)", supplement: [Eq.])

We define:
$ phi.alt := (1 + sqrt(5)) / 2 $ <ratio>

With @ratio, we get:
$ F_n = floor(1 / sqrt(5) phi.alt^n) $

pub fn block_in(styles: StyleChain<'_>) -> bool

Access the block field in the given style chain.

pub fn numbering_in(styles: StyleChain<'_>) -> &Option<Numbering>

Access the numbering field in the given style chain.

pub fn number_align_in( styles: StyleChain<'_>, ) -> SpecificAlignment<OuterHAlignment, VAlignment>

Access the number-align field in the given style chain.

pub fn supplement_in(styles: StyleChain<'_>) -> Smart<Option<Supplement>>

Access the supplement field in the given style chain.

pub fn size_in(styles: StyleChain<'_>) -> MathSize

Access the size field in the given style chain.

pub fn variant_in(styles: StyleChain<'_>) -> MathVariant

Access the variant field in the given style chain.

pub fn cramped_in(styles: StyleChain<'_>) -> bool

Access the cramped field in the given style chain.

pub fn bold_in(styles: StyleChain<'_>) -> bool

Access the bold field in the given style chain.

pub fn italic_in(styles: StyleChain<'_>) -> Smart<bool>

Access the italic field in the given style chain.

pub fn class_in(styles: StyleChain<'_>) -> Option<MathClass>

Access the class field in the given style chain.

pub fn script_scale_in(styles: StyleChain<'_>) -> (i16, i16)

Access the script-scale field in the given style chain.

pub fn set_block(block: bool) -> Property

Create a style property for the block field.

pub fn set_numbering(numbering: Option<Numbering>) -> Property

Create a style property for the numbering field.

pub fn set_number_align( number_align: SpecificAlignment<OuterHAlignment, VAlignment>, ) -> Property

Create a style property for the number-align field.

pub fn set_supplement(supplement: Smart<Option<Supplement>>) -> Property

Create a style property for the supplement field.

pub fn set_size(size: MathSize) -> Property

Create a style property for the size field.

pub fn set_variant(variant: MathVariant) -> Property

Create a style property for the variant field.

pub fn set_cramped(cramped: bool) -> Property

Create a style property for the cramped field.

pub fn set_bold(bold: bool) -> Property

Create a style property for the bold field.

pub fn set_italic(italic: Smart<bool>) -> Property

Create a style property for the italic field.

pub fn set_class(class: Option<MathClass>) -> Property

Create a style property for the class field.

pub fn set_script_scale(script_scale: (i16, i16)) -> Property

Create a style property for the script-scale field.

Trait Implementations

impl Capable for EquationElem

fn vtable(capability: TypeId) -> Option<NonNull<()>>

Get the pointer to the vtable for the given capability / trait.

impl Clone for EquationElem

fn clone(&self) -> EquationElem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Construct for EquationElem

fn construct(engine: &mut Engine<'_>, args: &mut Args) -> SourceResult<Content>

Construct an element from the arguments.

impl Debug for EquationElem

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

Formats the value using the given formatter.

impl Fields for EquationElem

type Enum = Fields

An enum with the fields of the element.

fn has(&self, id: u8) -> bool

Whether the element has the given field set.

fn field(&self, id: u8) -> Result<Value, FieldAccessError>

Get the field with the given field ID.

fn field_with_styles( &self, id: u8, styles: StyleChain<'_>, ) -> Result<Value, FieldAccessError>

Get the field with the given ID in the presence of styles.

fn field_from_styles( id: u8, styles: StyleChain<'_>, ) -> Result<Value, FieldAccessError>

Get the field with the given ID from the styles.

fn materialize(&mut self, styles: StyleChain<'_>)

Resolve all fields with the styles and save them in-place.

fn fields(&self) -> Dict

Get the fields of the element.

impl Hash for EquationElem

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 IntoValue for EquationElem

fn into_value(self) -> Value

Cast this type into a value.

impl NativeElement for EquationElem

fn data() -> &'static NativeElementData

Get the element data for the native Rust element.

fn elem() -> Element

where Self: Sized,

Get the element for the native Rust element.

fn pack(self) -> Content

where Self: Sized,

Pack the element into type-erased content.

impl PartialEq for EquationElem

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

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

const 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 Repr for EquationElem

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Set for EquationElem

fn set(engine: &mut Engine<'_>, args: &mut Args) -> SourceResult<Styles>

Parse relevant arguments into style properties for this element.