Context Navigation

-              r8b9c43
+              r783e88
 #include "CodePatterns/Log.hpp"
 #include "CodePatterns/Verbose.hpp"
+#include "LinearAlgebra/Exceptions.hpp"
 #include "LinearAlgebra/Line.hpp"
 #include "LinearAlgebra/Plane.hpp"
 …
     return true;
+  }
   catch (MathException &excp) {
     Log() << Verbose(1) << excp;
+  catch (LinearAlgebraException &excp) {
+    Log() << Verbose(1) << boost::diagnostic_information(excp);
     DoeLog(1) && (eLog() << Verbose(1) << "Alas! Intersection with plane failed - at least numerically - the intersection is not on the plane!" << endl);
     return false;
 …
     ClosestPoint = Plane(NormalVector, (endpoints[0]->node->getPosition())).GetIntersection(l);
+  }
   catch (MathException &excp) {
+  catch (LinearAlgebraException &excp) {
     (ClosestPoint) = (x);
+  }

src/Exceptions/Makefile.am

-              r8b9c43
+              r783e88
   CustomException.cpp \
   IllegalTypeException.cpp \
-  LinearDependenceException.cpp \
-  MathException.cpp \
   MissingValueException.cpp \
   NotOnSurfaceException.cpp \
 …
   CustomException.hpp \
   IllegalTypeException.hpp \
-  LinearDependenceException.hpp \
-  MathException.hpp \
   MissingValueException.hpp \
   NotOnSurfaceException.hpp \

src/LinearAlgebra/Exceptions.hpp

-              r8b9c43
+              r783e88
 typedef boost::error_info<struct tag_LinearAlgebraVector, const Vector* const> LinearAlgebraVector;
+/** Exception information for LinearAlgebraException: vector.
+ */
+typedef boost::error_info<
+    struct tag_LinearAlgebraVectorPair,
+    const std::pair<const Vector* const, const Vector* const> > LinearAlgebraVectorPair;
 /** ============================ Specific exceptions ====================== */
+/** Exception thrown when two vectors are parallel, i.e. linear dependent.
+ */
+struct LinearDependenceException : virtual LinearAlgebraException { };
+/** Exception thrown when are matrix is not invertiable, i.e. its determinant is NULL.
+ */
+struct MultipleSolutionsException : virtual LinearAlgebraException { };
+/** Exception thrown when are matrix is not invertiable, i.e. its determinant is NULL.
+ */
+struct NotInvertibleException : virtual LinearAlgebraException { };
 /** Exception thrown when two lines are skew, i.e. do not intersect.
  */
 struct SkewException : virtual LinearAlgebraException { };
-/** Exception thrown when are matrix is not invertiable, i.e. its determinant is NULL.
- */
-struct NotInvertibleException : virtual LinearAlgebraException { };
 /** Exception thrown when a vector with only zero components is invalidly encountered.

src/LinearAlgebra/Line.cpp

-              r8b9c43
+              r783e88
 #include "CodePatterns/Log.hpp"
 #include "CodePatterns/Verbose.hpp"
-#include "Exceptions/LinearDependenceException.hpp"
-#include "Exceptions.hpp"
 #include "LinearAlgebra/defs.hpp"
+#include "LinearAlgebra/Exceptions.hpp"
 #include "LinearAlgebra/MatrixContent.hpp"
 #include "LinearAlgebra/Plane.hpp"
 …
    res.Zero();
    Log() << Verbose(1) << "At least one of the lines is ill-defined, i.e. offset equals second vector." << endl;
    throw LinearDependenceException(__FILE__,__LINE__);
+   throw LinearDependenceException() << LinearAlgebraVectorPair( make_pair(&a, &b) );
+  }
 …
     Log() << Verbose(1) << "Lines are parallel." << endl;
     res.Zero();
     throw LinearDependenceException(__FILE__,__LINE__);
+    throw LinearDependenceException() << LinearAlgebraVectorPair( make_pair(&a, &b) );
+  }
 …
 Line makeLineThrough(const Vector &x1, const Vector &x2){
   if(x1==x2){
     throw LinearDependenceException(__FILE__,__LINE__);
+    throw LinearDependenceException() << LinearAlgebraVectorPair( make_pair(&x1, &x2) );
+  }
   return Line(x1,x1-x2);

src/LinearAlgebra/Plane.cpp

-              r8b9c43
+              r783e88
 #include "CodePatterns/Log.hpp"
 #include "CodePatterns/Verbose.hpp"
-#include "Exceptions/MultipleSolutionsException.hpp"
 #include "LinearAlgebra/defs.hpp"
 #include "LinearAlgebra/Exceptions.hpp"
 …
   normalVector(new Vector())
+{
+  Vector x1 = y1 -y2;
+  Vector x2 = y3 -y2;
+  if ((fabs(x1.Norm()) <= LINALG_MYEPSILON()) || (fabs(x2.Norm()) <= LINALG_MYEPSILON()) || (fabs(x1.Angle(x2)) <= LINALG_MYEPSILON())) {
+    throw LinearDependenceException(__FILE__,__LINE__);
+  Vector x1 = y1 - y2;
+  Vector x2 = y3 - y2;
+  if ((x1.Norm() <= LINALG_MYEPSILON())) {
+    throw LinearDependenceException() << LinearAlgebraVectorPair( make_pair(&y1, &y2) );
+  }
+  if ((x2.Norm() <= LINALG_MYEPSILON())) {
+    throw LinearDependenceException() << LinearAlgebraVectorPair( make_pair(&y2, &y3) );
+  }
+  if((fabs(x1.Angle(x2)) <= LINALG_MYEPSILON())) {
+    throw LinearDependenceException() << LinearAlgebraVectorPair( make_pair(&x1, &x2) );
+  }
 //  Log() << Verbose(4) << "relative, first plane coordinates:";
 …
   Vector x1 = y1;
   Vector x2 = y2;
   if ((fabs(x1.Norm()) <= LINALG_MYEPSILON())) {
+  if ((x1.Norm() <= LINALG_MYEPSILON())) {
     throw ZeroVectorException() << LinearAlgebraVector(&x1);
+  }
   if ((fabs(x2.Norm()) <= LINALG_MYEPSILON())) {
+  if ((x2.Norm() <= LINALG_MYEPSILON())) {
     throw ZeroVectorException() << LinearAlgebraVector(&x2);
+  }
   if((fabs(x1.Angle(x2)) <= LINALG_MYEPSILON())) {
     throw LinearDependenceException(__FILE__,__LINE__);
+    throw LinearDependenceException() << LinearAlgebraVectorPair( make_pair(&x1, &x2) );
+  }
 //  Log() << Verbose(4) << "relative, first plane coordinates:";
 …
   Vector res;
+  double factor1 = getNormal().ScalarProduct(line.getDirection());
+  res = getNormal();
+  const Vector direction = line.getDirection();
+  double factor1 = res.ScalarProduct(direction);
   if(fabs(factor1) <= LINALG_MYEPSILON()){
     // the plane is parallel... under all circumstances this is bad luck
     // we no have either no or infinite solutions
     if(isContained(line.getOrigin())){
+      throw MultipleSolutionsException<Vector>(__FILE__,__LINE__,line.getOrigin());
+      const Vector origin = line.getOrigin();
+      throw MultipleSolutionsException() << LinearAlgebraVector(&origin);
+    }
     else{
       throw LinearDependenceException(__FILE__,__LINE__);
+      throw LinearDependenceException() << LinearAlgebraVectorPair( make_pair(&res,  &direction) );
+    }
+  }

src/LinearAlgebra/Plane.hpp

r8b9c43	r783e88
21	21	#include "LinearAlgebra/Exceptions.hpp"
22	22	#include "LinearAlgebra/Space.hpp"
23		~~#include "Exceptions/LinearDependenceException.hpp"~~
24	23
25	24	class Vector;

src/LinearAlgebra/Vector.cpp

r8b9c43	r783e88
21	21	#include "CodePatterns/Assert.hpp"
22	22	#include "CodePatterns/Verbose.hpp"
23		~~#include "Exceptions/MathException.hpp"~~
24	23	#include "LinearAlgebra/defs.hpp"
25	24	#include "LinearAlgebra/fast_functions.hpp"

src/LinearAlgebra/unittests/LineUnitTest.cpp

r8b9c43	r783e88
21	21	#include "LinearAlgebra/Exceptions.hpp"
22	22	#include "LinearAlgebra/Vector.hpp"
23		~~#include "Exceptions/LinearDependenceException.hpp"~~
24	23
25	24	#include <cppunit/CompilerOutputter.h>

src/LinearAlgebra/unittests/VectorUnitTest.cpp

r8b9c43	r783e88
27	27
28	28	#include "CodePatterns/Log.hpp"
29		~~#include "Exceptions/LinearDependenceException.hpp"~~
30	29	#include "LinearAlgebra/defs.hpp"
31	30	#include "LinearAlgebra/Plane.hpp"

src/LinearAlgebra/vector_ops.cpp

r8b9c43	r783e88
20	20	#include "CodePatterns/MemDebug.hpp"
21	21
22		~~#include "Exceptions/LinearDependenceException.hpp"~~
23	22	#include "CodePatterns/Info.hpp"
24	23	#include "CodePatterns/Log.hpp"

src/molecule.cpp

-              r8b9c43
+              r783e88
 #include "config.hpp"
 #include "element.hpp"
-#include "Exceptions/LinearDependenceException.hpp"
 #include "graph.hpp"
 #include "Graph/BondGraph.hpp"
+#include "LinearAlgebra/Exceptions.hpp"
 #include "LinearAlgebra/leastsquaremin.hpp"
 #include "LinearAlgebra/Plane.hpp"
 …
         // determine the plane of these two with the *origin
         try {
           Orthovector1 =Plane(TopOrigin->getPosition(), FirstOtherAtom->getPosition(), SecondOtherAtom->getPosition()).getNormal();
+          Orthovector1 = Plane(TopOrigin->getPosition(), FirstOtherAtom->getPosition(), SecondOtherAtom->getPosition()).getNormal();
+        }
         catch(LinearDependenceException &excp){
           Log() << Verbose(0) << excp;
+          Log() << Verbose(0) << boost::diagnostic_information(excp);
           // TODO: figure out what to do with the Orthovector in this case
           AllWentWell = false;
 …
+      }
       catch(LinearDependenceException &excp) {
         Log() << Verbose(0) << excp;
+        Log() << Verbose(0) << boost::diagnostic_information(excp);
         AllWentWell = false;
+      }

src/tesselation.cpp

-              r8b9c43
+              r783e88
 #include "CodePatterns/Log.hpp"
 #include "CodePatterns/Verbose.hpp"
-#include "Exceptions/LinearDependenceException.hpp"
 #include "Helpers/helpers.hpp"
 #include "IPointCloud.hpp"
+#include "LinearAlgebra/Exceptions.hpp"
+#include "LinearAlgebra/Line.hpp"
+#include "LinearAlgebra/Plane.hpp"
 #include "LinearAlgebra/Vector.hpp"
-#include "LinearAlgebra/Line.hpp"
 #include "LinearAlgebra/vector_ops.hpp"
-#include "LinearAlgebra/Plane.hpp"
 #include "linkedcell.hpp"
 #include "PointCloudAdaptor.hpp"
 …
+                  }
                   catch (LinearDependenceException &excp){
                     Log() << Verbose(1) << excp;
+                    Log() << Verbose(1) << boost::diagnostic_information(excp);
                     Log() << Verbose(1) << "REJECT: Three points from " << *CandidateLine.BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
+                  }

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 783e88

Legend:

Download in other formats: