Add Term, Terms and TermSet- mirrors Pauli closely

zixy/src/fermion/operator/mod.rs

@@ -5,3 +5,6 @@ pub mod cmpnt_list;
 pub mod cre_or_ann;
 pub mod products;
 pub mod springs;
+pub mod term;
+pub mod term_set;
+pub mod terms;

zixy/src/fermion/operator/term.rs

@@ -0,0 +1,52 @@
+//! Single-term fermion utilities.
+
+use std::fmt::Display;
+
+use crate::container::coeffs::traits::NumRepr;
+use crate::container::traits::proj::Borrow;
+use crate::container::word_iters::terms;
+use crate::container::word_iters::terms::AsViewMut;
+use crate::fermion::mode::Modes;
+use crate::fermion::operator::cmpnt_list::CmpntList;
+use crate::fermion::operator::terms::Terms;
+use crate::fermion::traits::ModesBased;
+
+/// A single fermion operator with a generically-typed coefficient.
+pub type Term<C /*: NumRepr*/> = terms::Term<CmpntList, C>;
+
+impl<C: NumRepr> Term<C> {
+    /// Create a single fermion term with unit coefficient on the given mode space.
+    pub fn new(modes: Modes) -> Self {
+        let mut terms = Terms::<C>::new(modes);
+        terms.push_clear();
+        Self {
+            word_iters: terms.word_iters,
+            coeffs: terms.coeffs,
+        }
+    }
+}
+
+impl<C: NumRepr> Display for Term<C> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.borrow())
+    }
+}
+
+impl<C: NumRepr> ModesBased for Term<C> {
+    fn modes(&self) -> &Modes {
+        self.word_iters.modes()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::container::coeffs::unity::Unity;
+    use crate::container::traits::Elements;
+
+    #[test]
+    fn test_new_has_one_term() {
+        let term = Term::<Unity>::new(Modes::from_count(4));
+        assert_eq!(term.coeffs.len(), 1);
+    }
+}

zixy/src/fermion/operator/term_set.rs

@@ -0,0 +1,68 @@
+//! Stores fermion terms with the help of a `Map` to ensure each string appears at most once.
+
+use crate::container::coeffs::traits::NumRepr;
+use crate::container::map::Map;
+use crate::container::word_iters;
+use crate::fermion::mode::Modes;
+use crate::fermion::operator::cmpnt_list::CmpntList;
+use crate::fermion::operator::terms::Terms;
+use crate::fermion::traits::ModesBased;
+
+pub type TermSet<C /*: NumRepr*/> = word_iters::term_set::TermSet<CmpntList, C>;
+pub type View<'a, C /*: NumRepr*/> = word_iters::term_set::View<'a, CmpntList, C>;
+pub type ViewMut<'a, C /*: NumRepr*/> = word_iters::term_set::ViewMut<'a, CmpntList, C>;
+
+/// Trait for structs that immutably view a [`TermSet`].
+pub trait AsView<C: NumRepr>: word_iters::term_set::AsView<CmpntList, C> {}
+
+/// Trait for structs that mutably view a [`TermSet`].
+pub trait AsViewMut<C: NumRepr>: word_iters::term_set::AsViewMut<CmpntList, C> {}
+
+impl<C: NumRepr> AsView<C> for TermSet<C> {}
+impl<'a, C: NumRepr> AsView<C> for View<'a, C> {}
+impl<'a, C: NumRepr> AsView<C> for ViewMut<'a, C> {}
+
+impl<C: NumRepr> AsViewMut<C> for TermSet<C> {}
+impl<'a, C: NumRepr> AsViewMut<C> for ViewMut<'a, C> {}
+
+impl<C: NumRepr> TermSet<C> {
+    /// Create a new instance.
+    pub fn new(modes: Modes) -> Self {
+        Self {
+            terms: Terms::new(modes),
+            map: Map::default(),
+        }
+    }
+}
+
+impl<C: NumRepr> ModesBased for TermSet<C> {
+    fn modes(&self) -> &Modes {
+        self.terms.word_iters.modes()
+    }
+}
+
+impl<'a, C: NumRepr> ModesBased for View<'a, C> {
+    fn modes(&self) -> &Modes {
+        self.word_iters.modes()
+    }
+}
+
+impl<'a, C: NumRepr> ModesBased for ViewMut<'a, C> {
+    fn modes(&self) -> &Modes {
+        self.word_iters.modes()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::container::coeffs::unity::Unity;
+    use crate::container::traits::Elements;
+
+    #[test]
+    fn test_empty() {
+        let set = TermSet::<Unity>::new(Modes::from_count(4));
+        assert_eq!(set.len(), 0);
+        assert!(set.is_empty());
+    }
+}

zixy/src/fermion/operator/terms.rs

@@ -0,0 +1,79 @@
+//! Extends  fermion `CmpntList` fermion with associated coefficients.
+
+use crate::container::coeffs::traits::NumRepr;
+use crate::container::word_iters::terms;
+use crate::fermion::mode::Modes;
+use crate::fermion::operator::cmpnt_list::CmpntList;
+use crate::fermion::traits::ModesBased;
+
+/// A Fermion `CmpntList` paired with one coefficient per componenet, plus
+// immutable and mutable views into one.
+pub type Terms<C /*: NumRepr*/> = terms::Terms<CmpntList, C>;
+pub type View<'a, C /*: NumRepr*/> = terms::View<'a, CmpntList, C>;
+pub type ViewMut<'a, C /*: NumRepr*/> = terms::ViewMut<'a, CmpntList, C>;
+
+//Borrowed handles to a single fermion term inside a `Terms` container.
+pub type TermRef<'a, C /*: NumRepr*/> = terms::TermRef<'a, CmpntList, C>;
+pub type TermMutRef<'a, C /*: NumRepr*/> = terms::TermMutRef<'a, CmpntList, C>;
+
+/// Trait for structs that immutably view a fermion [`Terms`].
+/// Currently unused, but may be useful for future extensions.
+pub trait AsView<C: NumRepr>: terms::AsView<CmpntList, C> {}
+pub trait AsViewMut<C: NumRepr>: terms::AsViewMut<CmpntList, C> {}
+
+impl<C: NumRepr> AsView<C> for Terms<C> {}
+impl<'a, C: NumRepr> AsView<C> for View<'a, C> {}
+
+impl<C: NumRepr> AsViewMut<C> for Terms<C> {}
+impl<'a, C: NumRepr> AsViewMut<C> for ViewMut<'a, C> {}
+
+impl<C: NumRepr> Terms<C> {
+    /// Create a new  (empty) list of fermion terms on the given mode space.
+    pub fn new(modes: Modes) -> Self {
+        use crate::container::traits::EmptyFrom;
+        Self::empty_from(&CmpntList::new(modes))
+    }
+}
+
+impl<C: NumRepr> ModesBased for Terms<C> {
+    fn modes(&self) -> &Modes {
+        self.word_iters.modes()
+    }
+}
+
+impl<'a, C: NumRepr> ModesBased for View<'a, C> {
+    fn modes(&self) -> &Modes {
+        self.word_iters.modes()
+    }
+}
+
+impl<'a, C: NumRepr> ModesBased for ViewMut<'a, C> {
+    fn modes(&self) -> &Modes {
+        self.word_iters.modes()
+    }
+}
+
+impl<'a, C: NumRepr> ModesBased for TermRef<'a, C> {
+    fn modes(&self) -> &Modes {
+        self.word_iters.modes()
+    }
+}
+
+impl<'a, C: NumRepr> ModesBased for TermMutRef<'a, C> {
+    fn modes(&self) -> &Modes {
+        self.word_iters.modes()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::container::coeffs::unity::Unity;
+    use crate::container::traits::Elements;
+
+    #[test]
+    fn test_empty() {
+        let list = Terms::<Unity>::new(Modes::from_count(3));
+        assert!(list.is_empty());
+    }
+}