libs/cassowary/ClSymbolicWeight.cc

   1 // $Id$
   2 //
   3 // Cassowary Incremental Constraint Solver
   4 // Original Smalltalk Implementation by Alan Borning
   5 // This C++ Implementation by Greg J. Badros, <gjb@cs.washington.edu>
   6 // http://www.cs.washington.edu/homes/gjb
   7 // (C) 1998, 1999 Greg J. Badros and Alan Borning
   8 // See ../LICENSE for legal details regarding this software
   9 //
  10 // ClSymbolicWeight.cc
  11
  12 #include <cassowary/Cassowary.h>
  13 #include <cassowary/ClSymbolicWeight.h>
  14
  15 #ifdef HAVE_CONFIG_H
  16 #include <config.h>
  17 #define CONFIG_H_INCLUDED
  18 #endif
  19
  20 // Help g++ out, tell it to instantiate this
  21 //template vector<double> &vector<double>::operator =(const vector<double> &);
  22
  23 ClSymbolicWeight::ClSymbolicWeight(unsigned int CLevels, double value) :
  24   _values(CLevels, value)
  25 {
  26   assert(_values.size() == CLevels);
  27 }
  28
  29 ClSymbolicWeight::ClSymbolicWeight(double w1, double w2, double w3)
  30 {
  31   _values.push_back(w1);
  32   _values.push_back(w2);
  33   _values.push_back(w3);
  34   assert(_values.size() == 3);
  35 }
  36
  37 ClSymbolicWeight::ClSymbolicWeight(const vector<double> &weights) :
  38   _values(weights)
  39 { }
  40
  41 ClSymbolicWeight &
  42 ClSymbolicWeight::Zero()
  43 {
  44   static ClSymbolicWeight Zero(0.0, 0.0, 0.0);
  45   return Zero;
  46 }
  47
  48
  49 ClSymbolicWeight &
  50 ClSymbolicWeight::negated()
  51 {
  52   vector<double>::iterator it = _values.begin();
  53   for (; it != _values.end(); ++it)
  54     {
  55     *it = -*it;
  56     }
  57   return *this;
  58 }
  59
  60 ClSymbolicWeight &
  61 ClSymbolicWeight::MultiplyMe(Number n)
  62 {
  63   vector<double>::iterator it = _values.begin();
  64   for (; it != _values.end(); ++it)
  65     {
  66     *it *= n;
  67     }
  68   return *this;
  69 }
  70
  71
  72 ClSymbolicWeight
  73 ClSymbolicWeight::DivideBy(Number n) const
  74 {
  75   assert(n!=0);
  76   ClSymbolicWeight clsw(0);
  77   vector<double>::const_iterator i = _values.begin();
  78   for (; i != _values.end(); ++i)
  79     {
  80     clsw.push_back(*i / n);
  81     }
  82   return clsw;
  83 }
  84
  85 ClSymbolicWeight &
  86 ClSymbolicWeight::addtoMe(const ClSymbolicWeight &cl)
  87 {
  88   assert(cl.CLevels() == CLevels());
  89
  90   vector<double>::iterator i1 = _values.begin();
  91   vector<double>::const_iterator i2 = cl._values.begin();
  92   for (; i1 != _values.end(); ++i1, ++i2)
  93     {
  94     *i1 += *i2;
  95     }
  96   return *this;
  97 }
  98
  99 ClSymbolicWeight
 100 ClSymbolicWeight::Subtract(const ClSymbolicWeight &cl) const
 101 {
 102   assert(cl.CLevels() == CLevels());
 103
 104   ClSymbolicWeight clsw(0);
 105   vector<double>::const_iterator i1 = _values.begin();
 106   vector<double>::const_iterator i2 = cl._values.begin();
 107   for (; i1 != _values.end(); ++i1, ++i2)
 108     {
 109     clsw.push_back(*i1 - *i2);
 110     }
 111   return clsw;
 112 }
 113
 114
 115 bool
 116 ClSymbolicWeight::lessThan(const ClSymbolicWeight &cl) const
 117 {
 118   return _values < cl._values;
 119 }
 120
 121 bool
 122 ClSymbolicWeight::lessThanOrEqual(const ClSymbolicWeight &cl) const
 123 {
 124   return _values <= cl._values;
 125 }
 126
 127 bool
 128 ClSymbolicWeight::equal(const ClSymbolicWeight &cl) const
 129 {
 130   return _values == cl._values;
 131 }
 132
 133 bool
 134 ClSymbolicWeight::greaterThan(const ClSymbolicWeight &cl) const
 135 {
 136   return _values > cl._values;
 137 }
 138
 139 bool
 140 ClSymbolicWeight::greaterThanOrEqual(const ClSymbolicWeight &cl) const
 141 {
 142   return _values >= cl._values;
 143 }
 144
 145 bool
 146 ClSymbolicWeight::isNegative() const
 147 {
 148   return _values < Zero()._values;
 149 }