00001 /* @HEADER@ */ 00002 // ************************************************************************ 00003 // 00004 // Sundance 00005 // Copyright (2005) Sandia Corporation 00006 // 00007 // Copyright (year first published) Sandia Corporation. Under the terms 00008 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 00009 // retains certain rights in this software. 00010 // 00011 // This library is free software; you can redistribute it and/or modify 00012 // it under the terms of the GNU Lesser General Public License as 00013 // published by the Free Software Foundation; either version 2.1 of the 00014 // License, or (at your option) any later version. 00015 // 00016 // This library is distributed in the hope that it will be useful, but 00017 // WITHOUT ANY WARRANTY; without even the implied warranty of 00018 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00019 // Lesser General Public License for more details. 00020 // 00021 // You should have received a copy of the GNU Lesser General Public 00022 // License along with this library; if not, write to the Free Software 00023 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 00024 // USA 00025 // Questions? Contact Kevin Long (krlong@sandia.gov), 00026 // Sandia National Laboratories, Livermore, California, USA 00027 // 00028 // ************************************************************************ 00029 /* @HEADER@ */ 00030 00031 #include "SundanceSumExpr.hpp" 00032 #include "SundanceExpr.hpp" 00033 #include "PlayaTabs.hpp" 00034 #include "SundanceEvalManager.hpp" 00035 #include "SundanceSparsitySuperset.hpp" 00036 #include "SundanceOut.hpp" 00037 00038 00039 00040 using namespace Sundance; 00041 using namespace Sundance; 00042 using namespace Sundance; 00043 00044 using namespace Teuchos; 00045 00046 00047 SumExpr::SumExpr(const RCP<ScalarExpr>& left, 00048 const RCP<ScalarExpr>& right, int sign) 00049 : BinaryExpr(left, right, sign), sumTree_() 00050 { 00051 /* 00052 Expr L = Expr::handle(left); 00053 Expr R = Expr::handle(right); 00054 00055 sumTree_ = L.getSumTree(); 00056 Map<Expr, int> rightTree = R.getSumTree(); 00057 00058 for (Map<Expr, int>::const_iterator i=rightTree.begin(); i!=rightTree.end(); i++) 00059 { 00060 int leftCount = 0; 00061 if (sumTree_.containsKey(i->first)) 00062 { 00063 leftCount = sumTree_[i->first]; 00064 } 00065 int rightCount = sign * i->second; 00066 sumTree_.put(i->first, leftCount + rightCount); 00067 } 00068 */ 00069 } 00070 00071 bool SumExpr::isHungryDiffOp() const 00072 { 00073 return leftScalar()->isHungryDiffOp() || rightScalar()->isHungryDiffOp(); 00074 } 00075 00076 00077 const std::string& SumExpr::xmlTag() const 00078 { 00079 static std::string plusStr = "Plus"; 00080 static std::string minusStr = "Minus"; 00081 if (sign() < 0) return minusStr; 00082 return plusStr; 00083 } 00084 00085 const std::string& SumExpr::opChar() const 00086 { 00087 static std::string plusStr = "+"; 00088 static std::string minusStr = "-"; 00089 if (sign() < 0) return minusStr; 00090 return plusStr; 00091 } 00092 00093 00094 bool SumExpr::everyTermHasTestFunctions() const 00095 { 00096 return leftEvaluatable()->everyTermHasTestFunctions() 00097 && rightEvaluatable()->everyTermHasTestFunctions(); 00098 } 00099 00100 bool SumExpr::isLinearInTests() const 00101 { 00102 bool leftHasTests = leftScalar()->hasTestFunctions(); 00103 bool rightHasTests = rightScalar()->hasTestFunctions(); 00104 00105 bool leftIsLinear = leftScalar()->isLinearInTests(); 00106 bool rightIsLinear = rightScalar()->isLinearInTests(); 00107 00108 return (!leftHasTests || leftIsLinear) && (!rightHasTests || rightIsLinear); 00109 } 00110 00111 00112 bool SumExpr::isLinearForm(const Expr& u) const 00113 { 00114 bool LL = leftScalar()->isLinearForm(u); 00115 bool RL = rightScalar()->isLinearForm(u); 00116 bool LI = leftScalar()->isIndependentOf(u); 00117 bool RI = rightScalar()->isIndependentOf(u); 00118 00119 return ( (LL && (RL || RI)) || (RL && (LL || LI)) ); 00120 } 00121 00122 bool SumExpr::isQuadraticForm(const Expr& u) const 00123 { 00124 bool LQ = leftScalar()->isQuadraticForm(u); 00125 bool RQ = rightScalar()->isQuadraticForm(u); 00126 bool LL = leftScalar()->isLinearForm(u); 00127 bool RL = rightScalar()->isLinearForm(u); 00128 bool LI = leftScalar()->isIndependentOf(u); 00129 bool RI = rightScalar()->isIndependentOf(u); 00130 00131 return ( (LQ && (RQ || RL || RI)) || (RQ && (LQ || LL || LI))); 00132 }