Github... I'm not yet used to it.

1 files changed, 167 insertions, 0 deletions

diff --git a/anglerange.cpp b/anglerange.cpp
index 005f7b7..0bbbb5a 100644
--- a/anglerange.cpp
+++ b/anglerange.cpp
@@ -1,5 +1,172 @@
+/*
+ * LatticeMatch calculator - class used for angles
+ * Copyright (C) 2012 Andreas Grois
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *
+ * A small class that deals with ranges of angles. Its members are two angles, maximum and minimum.
+ * The main purpose of this class is to provide an easy way to determine the overlap of two ranges.
+ * There is no support for disjoint ranges (yet).
+ * Probably that would better be left for a separate class anyhow. Think: vector of anglerange objects
+ *
+ * There is an important convention with this class:
+ * Ranges are always clockwise from the lower to the upper bound.
+ * They include the lower and the upper bound, as this is required to be able to contain individual points.
+ *
+ * This class is part of the LatticeMatch program.
+ *
+ * To contact the author either use electronic mail: Andreas Grois <andreas.grois@jku.at>
+ * or write to:
+ * Andreas Grois, Institute for Semiconductor and SolidState physics, Johannes Kepler University,
+ * Altenbergerstraße 69, 4040 Linz, AUSTRIA
+ */
+
 #include "anglerange.h"
+#include <cmath>
 
 anglerange::anglerange()
 {
+    lowerborder = angleclass(0.0);
+    upperborder = angleclass(0.0);
+    upperset = false;
+    lowerset = false;
+}
+
+anglerange::anglerange(const angleclass &lower, const angleclass &upper)
+{
+    lowerborder = lower;
+    upperborder = upper;
+    upperset = true;
+    lowerset = true;
+}
+
+bool anglerange::isempty() const
+{
+    return(!upperset || !lowerset);
+}
+
+angleclass anglerange::getupper() const
+{
+    return(upperborder);
+}
+
+angleclass anglerange::getlower() const
+{
+    return(lowerborder);
+}
+
+void anglerange::setupper(const angleclass &newupper)
+{
+    upperborder=newupper;
+    upperset = true;
+}
+
+void anglerange::setlower(const angleclass &newlower)
+{
+    lowerborder=newlower;
+    lowerset = true;
+}
+
+void anglerange::setempty()
+{
+    upperset = false;
+    lowerset = false;
+    lowerborder = 0.0;
+    upperborder = 0.0;
+}
+
+anglerange anglerange::overlap(const anglerange &other)
+{
+    //storage for the return value:
+    anglerange retval; //anglerange constructor without arguments: emtpy range [0:0]
+    //first: if one of the input ranges is empty, don't do anything, leave retval empty!
+    if(!(isempty()) && !(other.isempty()))
+    {
+        //Here we need to take care to always follow the counter-clockwise convention.
+        //This leaves us with four possibilities:
+        //a) Both ranges contain the zero-line
+        //b) This range contains the zero-line, the other doesn'T
+        //c) Vice versa
+        //d) Both ranges are regular.
+
+        //first check if this range contains the zero-line
+        if(lowerborder>upperborder)
+        {
+            //ok, this range is around zero. Let's check the other one too:
+            if(other.getlower()>other.getupper())
+            {
+                //ok, both ranges contain the zero-line. This makes some things easier, as we know there's
+                //an overlap
+                retval.setlower(fmax(lowerborder.getval(),other.getlower().getval()));
+                retval.setupper(fmin(upperborder.getval(),other.getupper().getval()));
+            }
+            else
+            {
+                //this contains zero, other doesn't.
+                //This cannot fully lie within other, but other can lie fully within this.
+                //The result does obviously not contain zero.
+                //Let's check if other is within this.
+                if(other.getupper()<=upperborder || other.getlower()>=lowerborder){
+                    retval.setlower(other.getlower());
+                    retval.setupper(other.getupper());
+                }
+                else if(other.getupper()>=lowerborder) //not >, as per definition upperborder is inside range
+                {
+                    retval.setlower(lowerborder);
+                    retval.setupper(other.getupper());
+                }
+                else if(other.getlower()<=upperborder) //not <, as again upperborder is inside.
+                {
+                    retval.setlower(other.getlower());
+                    retval.setupper(upperborder);
+                }
+            }
+        }
+        else
+        {
+            //this is regular, is other as well?
+            if(other.getlower()>other.getupper())
+            {
+                //so, other cannot lie in this, but this can be in other.
+                //Let's check for that.
+                if(upperborder<=other.getupper() || lowerborder>=other.getlower()){
+                    retval.setlower(lowerborder);
+                    retval.setupper(upperborder);
+                }
+                else if(lowerborder <= other.getupper())
+                {
+                    retval.setlower(lowerborder);
+                    retval.setupper(other.getupper());
+                }
+                else if(upperborder >= other.getlower())
+                {
+                    retval.setlower(other.getlower());
+                    retval.setupper(upperborder);
+                }
+            }
+            else //both ranges regular
+            {
+                double curmax = fmin(other.getupper().getval(),upperborder.getval());
+                double curmin = fmax(other.getlower().getval(),lowerborder.getval());
+                if(curmax>=curmin){
+                    retval.setlower(curmin);
+                    retval.setupper(curmax);
+                }
+            }
+        }
+    }
+    return(retval);
 }