Struct Bond 

pub struct Bond {
    pub i: usize,
    pub j: usize,
    pub order: BondOrder,
}

A chemical bond between two atoms.

Represents a covalent bond with canonical ordering (i ≤ j) to ensure consistent hashing and equality comparisons. This allows bonds to be stored in hash-based collections without duplicates regardless of the order atoms are specified.

Fields

• i — Index of the first atom (always ≤ j)
• j — Index of the second atom (always ≥ i)
• order — Bond multiplicity (BondOrder)

Examples

use dreid_forge::{Bond, BondOrder};

// Order is automatically canonicalized
let bond1 = Bond::new(5, 2, BondOrder::Single);
let bond2 = Bond::new(2, 5, BondOrder::Single);

assert_eq!(bond1.i, 2); // smaller index
assert_eq!(bond1.j, 5); // larger index
assert_eq!(bond1, bond2); // equivalent regardless of input order

Fields

i: usize

Index of the first atom (canonically the smaller index).

j: usize

Index of the second atom (canonically the larger or equal index).

order: BondOrder

Bond order (single, double, triple, or aromatic).

Implementations

impl Bond

pub fn new(idx1: usize, idx2: usize, order: BondOrder) -> Self

Creates a new bond with canonical atom ordering.

Automatically orders atom indices so that i ≤ j, ensuring consistent representation regardless of the order arguments are provided.

Arguments

• idx1 — Index of the first atom
• idx2 — Index of the second atom
• order — Bond multiplicity

Returns

A new Bond with canonically ordered indices.

Trait Implementations

impl Clone for Bond

fn clone(&self) -> Bond

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Bond

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

Formats the value using the given formatter.

impl Hash for Bond

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 PartialEq for Bond

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

impl StructuralPartialEq for Bond