| /* Copyright 2015. Los Alamos National Security, LLC. This material was produced |
| * under U.S. Government contract DE-AC52-06NA25396 for Los Alamos National |
| * Laboratory (LANL), which is operated by Los Alamos National Security, LLC |
| * for the U.S. Department of Energy. The U.S. Government has rights to use, |
| * reproduce, and distribute this software. NEITHER THE GOVERNMENT NOR LOS |
| * ALAMOS NATIONAL SECURITY, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR |
| * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified |
| * to produce derivative works, such modified software should be clearly marked, |
| * so as not to confuse it with the version available from LANL. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy |
| * of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed |
| * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR |
| * CONDITIONS OF ANY KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations under the License. |
| * |
| * Under this license, it is required to include a reference to this work. We |
| * request that each derivative work contain a reference to LANL Copyright |
| * Disclosure C15076/LA-CC-15-054 so that this work's impact can be roughly |
| * measured. |
| * |
| * This is LANL Copyright Disclosure C15076/LA-CC-15-054 |
| */ |
| |
| /* |
| * PowerParser is a general purpose input file parser for software applications. |
| * |
| * Authors: Chuck Wingate XCP-2 caw@lanl.gov |
| * Robert Robey XCP-2 brobey@lanl.gov |
| */ |
| |
| // *************************************************************************** |
| // *************************************************************************** |
| // This class collects various parser math functions. |
| // |
| // There are two reasons to have this class: |
| // 1. To keep the command processing class from getting too big. |
| // 2. Some of these functions are used in more than one class. |
| // *************************************************************************** |
| // *************************************************************************** |
| |
| #include <iostream> |
| #include <iomanip> |
| #include <string> |
| #include <sstream> |
| #include <vector> |
| #include <deque> |
| #include <math.h> |
| |
| #include "Word.hh" |
| #include "Parser_math.hh" |
| |
| namespace PP |
| { |
| using std:: string; |
| using std::cout; |
| using std::endl; |
| using std::stringstream; |
| using std::setprecision; |
| using std::vector; |
| using std::deque; |
| |
| |
| // =========================================================================== |
| // Default constructor. |
| // =========================================================================== |
| Parser_math::Parser_math() |
| { |
| } |
| |
| |
| // =========================================================================== |
| // Do a single arithmetic binary operation involving 3 words. i1, on the left, |
| // is supposed to be a number, i2 is the operator, and i3, on the right, is |
| // supposed to be a number. |
| // The result is put in word wres. |
| // =========================================================================== |
| void Parser_math::do_op(int i1, int i2, int i3,deque <Word> &wq, Word &wres, |
| stringstream &serr, int &ierr) |
| { |
| // The words to the left and right of the operator have to be a number. |
| if ((!wq[i1].is_number()) || (!wq[i3].is_number())) { |
| wq[i2].fatal_error(serr, ierr); |
| serr << "Expected some number " << wq[i2].get_string() << |
| " some number" << endl; |
| serr << "But did not find a number, instead found" << endl; |
| serr << wq[i1].get_string() << wq[i2].get_string() << |
| wq[i3].get_string() << endl; |
| ierr = 2; |
| wres.set_value(0.); |
| return; |
| } |
| |
| |
| double d1 = wq[i1].get_double(); |
| string op = wq[i2].get_string(); |
| double d2 = wq[i3].get_double(); |
| |
| double result = 0.; |
| |
| if (op == "+") result = d1 + d2; |
| if (op == "-") result = d1 - d2; |
| if (op == "*") result = d1 * d2; |
| |
| if (op == "**") { |
| if (d1 == 0. && d2 >= 0.) { |
| wres.set_value(0.); |
| return; |
| } |
| |
| if (d1 == 0. && d2 < 0.) { |
| wq[i2].fatal_error(serr, ierr); |
| serr << "Trying to exponentiate 0 to a negative power." << endl; |
| serr << "Base = " << d1 << " Exponent = " << d2 << endl; |
| ierr = 2; |
| wres.set_value(0.); |
| return; |
| } |
| |
| if (d1 < 0. && !wq[i3].is_integer()) { |
| wq[i2].fatal_error(serr, ierr); |
| serr << "Trying to exponentiate a negative number to a non-integer power." << endl; |
| serr << "Base = " << d1 << " Exponent = " << d2 << endl; |
| ierr = 2; |
| wres.set_value(0.); |
| return; |
| } |
| |
| result = pow(d1,d2); |
| } |
| |
| if (op == "/") { |
| if (d2 == 0.) { |
| if (d1 == 0.) result = 0.; |
| else result = 1.e30; |
| wq[i2].fatal_error(serr, ierr); |
| serr << "Divide by 0." << endl; |
| serr << "Numerator = " << d1 << " Denominator = " << d2 << endl; |
| ierr = 2; |
| wres.set_value(result); |
| return; |
| } |
| result = d1 / d2; |
| } |
| |
| // Do not implement the % operator, it is too much like the fortran % |
| // operator which is for referencing components of a fortran structure. |
| /* |
| if (op == "%") { |
| if (d2 == 0.) { |
| result = 0.; |
| wq[i2].fatal_error(serr, ierr); |
| serr << "Modulus (%) second argument is 0." << endl; |
| serr << "First arg = " << d1 << " second arg = " << d2 << endl; |
| ierr = 2; |
| wres.set_value(result); |
| return; |
| } |
| result = ((int)d1) % ((int)d2); |
| } |
| */ |
| |
| wres.set_value(result); |
| } |
| |
| |
| // =========================================================================== |
| // Do a single relational binary operation involving 3 words. |
| // Relational operators include .eq., .ne., .le., ... |
| // The result is either true or false and is put in word wres. |
| // =========================================================================== |
| void Parser_math::do_op_relational(int i1, int i2, int i3, deque <Word> &wq, |
| Word &wres, stringstream &serr, int &ierr) |
| { |
| string s1 = wq[i1].get_string(); |
| string op = wq[i2].get_string(); |
| string s3 = wq[i3].get_string(); |
| bool result = false; |
| |
| //cout << "&&&&&cw op = " << s1 << op << s3 << endl; |
| |
| if ((wq[i1].is_bool()) && (wq[i3].is_bool())) { |
| if (op == ".gt." || op == ".ge." || op == ".lt." || op == ".le.") { |
| wq[i2].fatal_error(serr, ierr); |
| serr << "Does not make sense to compare logical values" << endl; |
| serr << " with greater than or less than" << endl; |
| serr << " " << s1 << " " << op << " " << s3 << endl; |
| ierr = 2; |
| wres.set_value(false); |
| return; |
| } |
| } |
| |
| if ( ((wq[i1].is_bool()) && (!wq[i3].is_bool())) || |
| ((!wq[i1].is_bool()) && (wq[i3].is_bool())) |
| ) { |
| wq[i2].fatal_error(serr, ierr); |
| serr << "Does not make sense to compare logical and" << endl; |
| serr << " non-logical values" << endl; |
| serr << " " << s1 << " " << op << " " << s3 << endl; |
| ierr = 2; |
| wres.set_value(false); |
| return; |
| } |
| |
| if ( ((wq[i1].is_number()) && (!wq[i3].is_number())) || |
| ((!wq[i1].is_number()) && (wq[i3].is_number())) |
| ) { |
| wq[i2].fatal_error(serr, ierr); |
| serr << "Does not make sense to compare numerical and" << endl; |
| serr << " non-numerical values" << endl; |
| serr << " " << s1 << " " << op << " " << s3 << endl; |
| ierr = 2; |
| wres.set_value(false); |
| return; |
| } |
| |
| // Compare two numbers. |
| if ( (wq[i1].is_number()) && (wq[i3].is_number()) ) { |
| double d1 = wq[i1].get_double(); |
| double d3 = wq[i3].get_double(); |
| if (op == ".gt.") result = d1 > d3; |
| if (op == ".ge.") result = d1 >= d3; |
| if (op == ".lt.") result = d1 < d3; |
| if (op == ".le.") result = d1 <= d3; |
| if (op == ".eq.") result = d1 == d3; |
| if (op == ".ne.") result = d1 != d3; |
| //cout << "&&&&&cw relational result = " << result << endl; |
| wres.set_value(result); |
| return; |
| } |
| |
| if ( (wq[i1].is_bool()) && (wq[i3].is_bool()) ) { |
| bool b1 = wq[i1].get_bool(serr, ierr); |
| bool b3 = wq[i3].get_bool(serr, ierr); |
| if (op == ".eq.") result = b1 == b3; |
| if (op == ".ne.") result = b1 != b3; |
| //cout << "&&&&&cw relational result = " << result << endl; |
| wres.set_value(result); |
| return; |
| } |
| |
| // Compare two strings. |
| if (op == ".gt.") result = s1 > s3; |
| if (op == ".ge.") result = s1 >= s3; |
| if (op == ".lt.") result = s1 < s3; |
| if (op == ".le.") result = s1 <= s3; |
| if (op == ".eq.") result = s1 == s3; |
| if (op == ".ne.") result = s1 != s3; |
| wres.set_value(result); |
| return; |
| } |
| |
| // =========================================================================== |
| // Do the .not. operation, this is different from all the others in that |
| // .not. is a unary operator, the others are binary ops. |
| // The result is either true or false and is put in word wres. |
| // =========================================================================== |
| void Parser_math::do_op_not(int i2, int i3, deque <Word> &wq, |
| Word &wres, stringstream &serr, int &ierr) |
| { |
| string op = wq[i2].get_string(); |
| string s3 = wq[i3].get_string(); |
| bool result = false; |
| |
| if (!wq[i3].is_bool()) { |
| wq[i2].fatal_error(serr, ierr); |
| serr << "The word following the .not. operator must be" |
| " true or false." << endl; |
| serr << "Instead the word following .not. is " << s3 << endl; |
| ierr = 2; |
| wres.set_value(false); |
| return; |
| } |
| |
| result = true; |
| if (wq[i3].get_bool(serr, ierr) == true) result = false; |
| wres.set_value(result); |
| return; |
| } |
| |
| |
| // =========================================================================== |
| // Do a single logical binary operation involving 3 words. |
| // The binary logical operators are .and. and .or. |
| // The result is either true or false and is put in word wres. |
| // =========================================================================== |
| void Parser_math::do_op_logical(int i1, int i2, int i3, deque <Word> &wq, |
| Word &wres, stringstream &serr, int &ierr) |
| { |
| string s1 = wq[i1].get_string(); |
| string op = wq[i2].get_string(); |
| string s3 = wq[i3].get_string(); |
| bool result = false; |
| |
| //cout << "&&&&&cw logical = " << s1 << op << s3 << endl; |
| |
| // For .and. and .or., both operands must be boolean. |
| if ((!wq[i1].is_bool()) || (!wq[i3].is_bool())) { |
| wq[i2].fatal_error(serr, ierr); |
| serr << "The operator is " << op << endl; |
| serr << "The two operands (on the left and right of the operator)" << endl; |
| serr << "must be logical values (true or false)." << endl; |
| serr << " " << s1 << " " << op << " " << s3 << endl; |
| ierr = 2; |
| wres.set_value(false); |
| return; |
| } |
| |
| bool b1 = wq[i1].get_bool(serr, ierr); |
| bool b3 = wq[i3].get_bool(serr, ierr); |
| if (op == ".and.") result = b1 && b3; |
| if (op == ".or.") result = b1 || b3; |
| //cout << "&&&&&cw logical result = " << result << endl; |
| wres.set_value(result); |
| return; |
| } |
| |
| |
| |
| } // End of the PP namespace |
