From 1da9ba0af64dd1ff07c9fda6226689b4e8701e43 Mon Sep 17 00:00:00 2001
From: Jaron Kent-Dobias <jaron@kent-dobias.com>
Date: Tue, 25 Feb 2020 15:23:41 -0500
Subject: Minor refactoring of sphere commands and animation class, and
 introduction of Dimers

---
 euclidean.hpp | 52 +++++++++++++++++++++++++++++++---------------------
 1 file changed, 31 insertions(+), 21 deletions(-)

(limited to 'euclidean.hpp')

diff --git a/euclidean.hpp b/euclidean.hpp
index b1ce2c6..fb2dbcd 100644
--- a/euclidean.hpp
+++ b/euclidean.hpp
@@ -5,6 +5,15 @@
 #include "spin.hpp"
 #include "vector.hpp"
 
+typedef double Radius;
+typedef signed IsingSpin;
+
+template <class T, int D> class Dimer {
+public:
+  double radius;
+  Vector<T, D> relativePosition;
+};
+
 template <class T, int D> class Euclidean {
 public:
   Vector<T, D> t;
@@ -25,36 +34,27 @@ public:
     r = r0;
   }
 
-  Vector<T, D> act(const Vector<T, D>& x) const {
-    return t + r * x;
-  }
-
-  template <class S> Spin<T, D, S> act(const Spin<T, D, S>& s) const {
-    Spin<T, D, S> s_new;
-
-    s_new.x = this->act(s.x);
-    s_new.s = s.s;
+  Vector<T, D> act(const Vector<T, D>& x) const { return t + r * x; }
 
-    return s_new;
+  template <typename U> Vector<U, D> act(const Vector<U, D>& x) const {
+    return t.template cast<U>() + r.template cast<U>() * x;
   }
 
-  Euclidean act(const Euclidean& x) const {
-    Vector<T, D> tnew = r * x.t + t;
-    Matrix<T, D> rnew = r * x.r;
+  Radius act(Radius r) const { return r; }
 
-    Euclidean pnew(tnew, rnew);
+  IsingSpin act(IsingSpin s) const { return s; }
 
-    return pnew;
+  Dimer<T, D> act(const Dimer<T, D>& d) const {
+    return {.radius = d.radius, .relativePosition = r * d.relativePosition};
   }
 
-  Euclidean inverse() const {
-    Vector<T, D> tnew = -r.transpose() * t;
-    Matrix<T, D> rnew = r.transpose();
+  template <class S> Spin<T, D, S> act(const Spin<T, D, S>& s) const {
+    return {.x = act(s.x), .s = act(s.s)};
+  }
 
-    Euclidean pnew(tnew, rnew);
+  Euclidean act(const Euclidean& x) const { return Euclidean(r * x.t + t, r * x.r); }
 
-    return pnew;
-  }
+  Euclidean inverse() const { return Euclidean(-r.transpose() * t, r.transpose()); }
 };
 
 template <class T, int D> class TorusGroup {
@@ -105,6 +105,16 @@ public:
     return s_new;
   }
 
+  template <typename U> Vector<U, D> act(const Vector<U, D>& s) const {
+    Vector<U, D> s_new = t.template cast<U>() + r.template cast<U>() * s;
+
+    for (unsigned i = 0; i < D; i++) {
+      s_new(i) = fmod(L + s_new(i), L);
+    }
+
+    return s_new;
+  }
+
   TorusGroup act(const TorusGroup& x) const {
     Vector<T, D> tnew = r * x.t + t;
     Matrix<T, D> rnew = r * x.r;
-- 
cgit v1.2.3-54-g00ecf