Changeset 534

Timestamp:

Oct 9, 2006 12:41:16 PM (18 years ago)

Author:

dkearney

Message:

added incarnate functionality to units objects so we can begin to think about conversions like m3<->L.
added new algorithm for applying conversion functions.
added concentration (pH and pOH) and several other units.
added/fixed several units conversion functions.

Location:

trunk/src/core

Files:

• RpUnits.cc (modified) (34 diffs)
• RpUnits.h (modified) (15 diffs)
• RpUnitsStd.cc (modified) (11 diffs)
• RpUnitsStd.h (modified) (9 diffs)

trunk/src/core/RpUnits.cc

@@ -93 +93 @@
 
 /**********************************************************************/
+// METHOD: incarnate()
+/// Link two RpUnits where the entity is an incarnate of the abstraction
+/**
+ */
+
+int
+RpUnits::incarnate(const RpUnits* abstraction, const RpUnits* entity) {
+
+    int retVal = 1;
+
+    abstraction->connectIncarnation(entity);
+    entity->connectIncarnation(abstraction);
+
+    retVal = 0;
+    return retVal;
+}
+
+/**********************************************************************/
 // METHOD: grabExponent()
 /// Return exponent from a units string containing a unit name and exponent
@@ -191 +209 @@
     std::list<std::string> compatList;
     std::list<std::string> basisCompatList;
-    std::string myName          = getUnitsName();
-    // std::stringstream otherName;
-    std::string otherName       = "";
+    std::list<std::string> incarnationCompatList;
+    std::stringstream myName;
+    std::stringstream otherName;
     std::string otherBasisName  = "";
     std::string blank           = "";
-    // double otherExp             = 1.0;
+    double otherExp             = 1.0;
+    double myExp                = 1.0;
+    double incExp               = 1.0;
     convEntry* myConversions    = this->convList;
+    incarnationEntry* myIncarnations = this->incarnationList;
     const RpUnits * basis       = NULL;
 
+    myName.str("");
+    myName << getUnits();
+    myExp = getExponent() * expMultiplier;
+
     if (this->basis) {
-        basisCompatList = this->basis->getCompatible();
+        basisCompatList = this->basis->getCompatible(expMultiplier);
         compatList.merge(basisCompatList);
     }
@@ -215 +240 @@
         while (myConversions != NULL) {
 
-            otherName = myConversions->conv->toPtr->getUnitsName();
-            /*
             otherName.str("");
-            otherName << myConversions->conv->toPtr->getUnitsName();
-            otherExp = myConversions->conv->fromPtr->getExponent();
-            if ( (otherExp != 1) && (expMultiplier != 1) ) {
-                otherName << otherExp * expMultiplier;
-            }
-            */
+            // otherName << myConversions->conv->toPtr->getUnitsName();
+            otherName << myConversions->conv->toPtr->getUnits();
+            otherExp = myConversions->conv->toPtr->getExponent();
             basis = myConversions->conv->toPtr->basis;
 
-            // if (myName == otherName.str()) {
-            if (myName == otherName) {
-                otherName = myConversions->conv->fromPtr->getUnitsName();
-                /*
+            if (myName.str() == otherName.str()) {
                 otherName.str("");
-                otherName << myConversions->conv->fromPtr->getUnitsName();
-                if ( (otherExp != 1) && (expMultiplier != 1) ) {
-                    otherExp = myConversions->conv->fromPtr->getExponent();
-                    otherName << otherExp * expMultiplier;
-                }
-                */
+                // otherName << myConversions->conv->fromPtr->getUnitsName();
+                otherName << myConversions->conv->fromPtr->getUnits();
+                otherExp = myConversions->conv->fromPtr->getExponent();
                 basis = myConversions->conv->fromPtr->basis;
             }
@@ -243 +257 @@
             // no need to list all of the metric conversions.
             if (basis) {
-                if (basis->getUnitsName() == myName) {
+                if (basis->getUnitsName() == myName.str()) {
                     // do not add this unit to the conversion
                     // because its a derived unit.
@@ -251 +265 @@
             }
 
+            // adjust the exponent as requested by fxn caller
+            otherExp = otherExp * expMultiplier;
+
+            // adjust the other units name to match exponent
+            if ( (otherExp > 0) && (otherExp != 1) ) {
+                otherName << otherExp;
+            }
+            else if (otherExp < 0) {
+                otherName.str("/"+otherName.str());
+                if (otherExp < -1) {
+                    otherName.seekp(0,std::ios_base::end);
+                    otherName << otherExp*-1;
+                }
+            }
+
             // add the other unit's name to the list of compatible units
-            // compatList.push_back(otherName.str());
-            compatList.push_back(otherName);
+            compatList.push_back(otherName.str());
+            // compatList.push_back(otherName);
 
             // advance to the next conversion
             myConversions = myConversions->next;
         }
-    }
-
-    compatList.push_back(myName);
+
+        // now go throught the incarnation list to see if there are other
+        // compatible units listed there.
+        while (myIncarnations != NULL) {
+            incExp = myIncarnations->unit->getExponent();
+            if (incExp == myExp) {
+                incarnationCompatList = myIncarnations->unit->getCompatible();
+                compatList.merge(incarnationCompatList);
+                break;
+            }
+            else if ((-1.0*incExp) == myExp) {
+                incarnationCompatList = myIncarnations->unit->getCompatible(-1);
+                compatList.merge(incarnationCompatList);
+                break;
+            }
+            else if (   (myExp == int(myExp))   &&
+                        (incExp == int(incExp)) &&
+                        ( (int(myExp)%int(incExp)) == 0) &&
+                        ( (myExp/incExp) != 1)  &&
+                        ( (myExp/incExp) != -1) &&
+                        ( myExp != 1 )          &&
+                        ( myExp != -1 )         &&
+                        ( incExp != 1 )         &&
+                        ( incExp != -1 )        ) {
+                incarnationCompatList = myIncarnations->unit->getCompatible(myExp/incExp);
+                compatList.merge(incarnationCompatList);
+                break;
+            }
+            else {
+                // do nothing
+            }
+            myIncarnations = myIncarnations->next;
+        }
+    }
+
+    // adjust the exponent as requested by fxn caller
+    // myExp = myExp * expMultiplier;
+
+    // adjust the other units name to match exponent
+    if ( (expMultiplier > 0) && (expMultiplier != 1) ) {
+        // myName << expMultiplier;
+        myName << myExp;
+    }
+    else if (expMultiplier < 0) {
+        myName.str("/"+myName.str());
+        if (myExp < -1) {
+            myName.seekp(0,std::ios_base::end);
+            myName << myExp*-1;
+        }
+    }
+
+    compatList.push_back(myName.str());
     compatList.sort();
     compatList.unique();
@@ -266 +344 @@
 
 }
+
+
+
 
 /**********************************************************************/
@@ -521 +602 @@
     std::string name;
 
+    name = "d" + basisName;
+    RpUnits * deci = RpUnits::define(name, basis, basis->type);
+    RpUnits::define(deci, basis, deci2base, base2deci);
+
     name = "c" + basisName;
     RpUnits * centi = RpUnits::define(name, basis, basis->type);
@@ -549 +634 @@
     RpUnits::define(atto, basis, atto2base, base2atto);
 
+    name = "da" + basisName;
+    RpUnits * deca  = RpUnits::define(name, basis, basis->type);
+    RpUnits::define(deca, basis, deca2base, base2deca);
+
+    name = "h" + basisName;
+    RpUnits * hecto  = RpUnits::define(name, basis, basis->type);
+    RpUnits::define(hecto, basis, hecto2base, base2hecto);
+
     name = "k" + basisName;
     RpUnits * kilo  = RpUnits::define(name, basis, basis->type);
@@ -568 +661 @@
     RpUnits * peta  = RpUnits::define(name, basis, basis->type);
     RpUnits::define(peta, basis, peta2base, base2peta);
+
+    name = "E" + basisName;
+    RpUnits * exa  = RpUnits::define(name, basis, basis->type);
+    RpUnits::define(exa, basis, exa2base, base2exa);
 
     return (1);
@@ -618 +715 @@
  * returns error (a non-zero value).
  * 
- * this code is very similar to units2list()
- *
  * if &compatList == NULL, no compatible list of units will be generated.
  * this function does not do a good job of placing the available units 
@@ -633 +728 @@
     std::string sendUnitStr = "";
     double exponent         = 1;
-    int offset              = 0;
-    int idx                 = 0;
-    int last                = 0;
-    int err                 = 0; // did we come across an unrecognized unit
+    int err                 = 0;
     const RpUnits* unit     = NULL;
     std::list<std::string> basisCompatList;
     std::list<std::string>::iterator compatListIter;
     std::stringstream unitWExp;
+    RpUnitsList inUnitsList;
+    RpUnitsListIter inIter;
+
+    // err tells us if we encountered any unrecognized units
+    err = RpUnits::units2list(inUnits,inUnitsList,type);
+    inIter = inUnitsList.begin();
+
+    while ( inIter != inUnitsList.end() ) {
+
+        unit = inIter->getUnitsObj();
+        exponent = inIter->getExponent();
+
+        // merge the compatible units
+        if (compatList) {
+
+            basisCompatList = unit->getCompatible(exponent);
+            compatList->merge(basisCompatList);
+        }
+
+        inIter++;
+    }
+
+    // clean out any duplicate entries.
+    if (compatList) {
+        compatList->unique();
+    }
+
+    return err;
+}
+
+
+/**********************************************************************/
+// METHOD: negateListExponents()
+/// Negate the exponents on every element in unitsList
+/**
+ */
+
+int
+RpUnits::negateListExponents(RpUnitsList& unitsList) {
+    RpUnitsListIter iter = unitsList.begin();
+    int nodeCnt = unitsList.size();
+
+    if (nodeCnt > 0) {
+        for (; iter != unitsList.end(); iter++) {
+            iter->negateExponent();
+            nodeCnt--;
+        }
+    }
+
+    return nodeCnt;
+}
+
+/**********************************************************************/
+// METHOD: negateExponent()
+/// Negate the exponent on the current RpUnitsListEntry
+/**
+ */
+
+void
+RpUnitsListEntry::negateExponent() const {
+    exponent = exponent * -1;
+    return;
+}
+
+/**********************************************************************/
+// METHOD: name()
+/// Provide the caller with the name of this object
+/**
+ */
+
+std::string
+RpUnitsListEntry::name() const {
+    std::stringstream name;
+    name << unit->getUnits() << exponent;
+    return std::string(name.str());
+}
+
+/**********************************************************************/
+// METHOD: define()
+/// Provide the caller with the basis of the RpUnits object being stored
+/**
+ */
+
+const RpUnits*
+RpUnitsListEntry::getBasis() const {
+    return unit->getBasis();
+}
+
+/**********************************************************************/
+// METHOD: getUnitsObj()
+/// Return the RpUnits Object from a RpUnitsListEntry.
+/**
+ */
+
+const RpUnits*
+RpUnitsListEntry::getUnitsObj() const {
+    return unit;
+}
+
+/**********************************************************************/
+// METHOD: getExponent()
+/// Return the exponent of an RpUnitsListEntry.
+/**
+ */
+
+double
+RpUnitsListEntry::getExponent() const {
+    return exponent;
+}
+
+/**********************************************************************/
+// METHOD: printList()
+/// Traverse a RpUnitsList and print out the name of each element.
+/**
+ */
+
+int
+RpUnits::printList(RpUnitsList& unitsList) {
+    RpUnitsListIter iter = unitsList.begin();
+    int nodeCnt = unitsList.size();
+
+    if (nodeCnt > 0) {
+        for (; iter != unitsList.end(); iter++) {
+            std::cout << iter->name() << " ";
+            nodeCnt--;
+        }
+        std::cout << std::endl;
+    }
+
+    return nodeCnt;
+}
+
+/**********************************************************************/
+// METHOD: units2list()
+/// Split a string of units into a list of base units with exponents.
+/**
+ * Splits a string of units like cm2/kVns into a list of units like
+ * cm2, kV1, ns1 where an exponent is provided for each list entry.
+ * List entries are found by comparing units strings to the names
+ * in the dictionary.
+ */
+
+int
+RpUnits::units2list ( const std::string& inUnits,
+                      RpUnitsList& outList,
+                      std::string& type ) {
+
+    std::string myInUnits   = inUnits;
+    std::stringstream sendUnitStr;
+    double exponent         = 1;
+    int offset              = 0;
+    int idx                 = 0;
+    int last                = 0;
+    int err                 = 0;
+    const RpUnits* unit     = NULL;
 
 
@@ -650 +897 @@
             type = myInUnits[last] + type;
             myInUnits.erase(last);
+            // multiply previous exponents by -1
+            if ( ! outList.empty() ) {
+                RpUnits::negateListExponents(outList);
+            }
             continue;
         }
@@ -663 +914 @@
 
         // figure out if we have some defined units in that string
-        sendUnitStr = myInUnits.substr(offset,std::string::npos);
-        if ((unit = grabUnits(sendUnitStr,&offset))) {
-            // a unit was found
-            // erase the found unit's name from our search string
-            myInUnits.erase(idx+offset);
-
-            // add the type to the type string
-            type = unit->getType() + type;
-
-            // merge the compatible units
-            if (compatList) {
-                basisCompatList = unit->getCompatible(exponent);
-
-                // adjust exponents as necessary
-                if ( (exponent != 0) && (exponent != 1) ) {
-                    compatListIter = compatList->begin();
-                    while (compatListIter != compatList->end()) {
-                        unitWExp << *compatListIter << exponent;
-                        *compatListIter = unitWExp.str();
-                    }
-                }
-
-                compatList->merge(basisCompatList);
-            }
-        }
-        else {
-            // we came across a unit we did not recognize
-            // raise error and exit
-            err++;
-            break;
-        }
-
-        // reset our vars
-        idx = 0;
-        offset = 0;
-        exponent = 1;
-    }
-
-    // clean out any duplicate entries.
-    if (compatList) {
-        compatList->unique();
-    }
-
-    return err;
-}
-
-
-/**********************************************************************/
-// METHOD: negateListExponents()
-/// Negate the exponents on every element in unitsList
-/**
- */
-
-int
-RpUnits::negateListExponents(RpUnitsList& unitsList) {
-    RpUnitsListIter iter = unitsList.begin();
-    int nodeCnt = unitsList.size();
-
-    if (nodeCnt > 0) {
-        for (; iter != unitsList.end(); iter++) {
-            iter->negateExponent();
-            nodeCnt--;
-        }
-    }
-
-    return nodeCnt;
-}
-
-/**********************************************************************/
-// METHOD: negateExponent()
-/// Negate the exponent on the current RpUnitsListEntry
-/**
- */
-
-void
-RpUnitsListEntry::negateExponent() const {
-    exponent = exponent * -1;
-    return;
-}
-
-/**********************************************************************/
-// METHOD: name()
-/// Provide the caller with the name of this object
-/**
- */
-
-std::string
-RpUnitsListEntry::name() const {
-    std::stringstream name;
-    name << unit->getUnits() << exponent;
-    return std::string(name.str());
-}
-
-/**********************************************************************/
-// METHOD: define()
-/// Provide the caller with the basis of the RpUnits object being stored
-/**
- */
-
-const RpUnits*
-RpUnitsListEntry::getBasis() const {
-    return unit->getBasis();
-}
-
-/**********************************************************************/
-// METHOD: getUnitsObj()
-/// Return the RpUnits Object from a RpUnitsListEntry.
-/**
- */
-
-const RpUnits*
-RpUnitsListEntry::getUnitsObj() const {
-    return unit;
-}
-
-/**********************************************************************/
-// METHOD: getExponent()
-/// Return the exponent of an RpUnitsListEntry.
-/**
- */
-
-double
-RpUnitsListEntry::getExponent() const {
-    return exponent;
-}
-
-/**********************************************************************/
-// METHOD: printList()
-/// Traverse a RpUnitsList and print out the name of each element.
-/**
- */
-
-int
-RpUnits::printList(RpUnitsList& unitsList) {
-    RpUnitsListIter iter = unitsList.begin();
-    int nodeCnt = unitsList.size();
-
-    if (nodeCnt > 0) {
-        for (; iter != unitsList.end(); iter++) {
-            std::cout << iter->name() << " ";
-            nodeCnt--;
-        }
-        std::cout << std::endl;
-    }
-
-    return nodeCnt;
-}
-
-/**********************************************************************/
-// METHOD: units2list()
-/// Split a string of units into a list of base units with exponents.
-/**
- * Splits a string of units like cm2/kVns into a list of units like
- * cm2, kV1, ns1 where an exponent is provided for each list entry.
- * List entries are found by comparing units strings to the names
- * in the dictionary.
- */
-
-int
-RpUnits::units2list ( const std::string& inUnits,
-                      RpUnitsList& outList ) {
-
-    std::string myInUnits   = inUnits;
-    std::string sendUnitStr = "";
-    double exponent         = 1;
-    int offset              = 0;
-    int idx                 = 0;
-    int last                = 0;
-    const RpUnits* unit     = NULL;
-
-
-    while ( !myInUnits.empty() ) {
-
-        // check to see if we came across a '/' character
-        last = myInUnits.length()-1;
-        if (myInUnits[last] == '/') {
-            myInUnits.erase(last);
-            // multiply previous exponents by -1
-            if ( ! outList.empty() ) {
-                RpUnits::negateListExponents(outList);
-            }
-            continue;
-        }
-
-        // get the exponent
-        offset = RpUnits::grabExponent(myInUnits,&exponent);
-        myInUnits.erase(offset);
-        idx = offset - 1;
-
-        // grab the largest string we can find
-        offset = RpUnits::grabUnitString(myInUnits);
-        idx = offset;
-
-        // figure out if we have some defined units in that string
-        sendUnitStr = myInUnits.substr(offset,std::string::npos);
-        unit = grabUnits(sendUnitStr,&offset);
+        sendUnitStr.str(myInUnits.substr(offset,std::string::npos));
+        unit = grabUnits(sendUnitStr.str(),&offset);
         if (unit) {
             // a unit was found
@@ -864 +921 @@
             // erase the found unit's name from our search string
             outList.push_front(RpUnitsListEntry(unit,exponent));
+            type = unit->getType() + type;
             myInUnits.erase(idx+offset);
         }
@@ -869 +927 @@
             // we came across a unit we did not recognize
             // raise error and delete character for now
+            err = 1;
             myInUnits.erase(last);
         }
+
+        /*
+        // if the exponent != 1,-1 then do a second search 
+        // for the unit+exponent string that might be defined.
+        // this is to cover the case were we have defined conversions
+        // m3<->gal, m3<->L but m is defined
+        if ( (exponent != 1) && (exponent != -1) ) {
+            sendUnitStr.str("");
+            sendUnitStr << unit->getUnits() << exponent;
+            unit = grabUnits(sendUnitStr.str(),&offset);
+            if (unit) {
+                // a unit was found
+                // add this unit to the list
+                outList.push_front(RpUnitsListEntry(unit,1.0));
+            }
+            else {
+                // we came across a unit we did not recognize
+                // do nothing
+            }
+        }
+        */
 
         // reset our vars
@@ -878 +958 @@
     }
 
-    return 0;
+    return err;
 }
 
@@ -1006 +1086 @@
  */
 
+
 std::string
 RpUnits::convert (  std::string val,
@@ -1025 +1106 @@
     std::string fromUnitsName = "";
     std::string convVal = "";
+    std::string type = "";     // junk var used because units2list requires it
     double origNumVal = 0;
     double numVal = 0;
@@ -1033 +1115 @@
     std::stringstream outVal;
 
-    int rv = 0;
-    double factor = 1;
+    double copies = 0;
+
+    convertList cList;
+    convertList totalConvList;
 
 
@@ -1105 +1189 @@
     }
 
-    RpUnits::units2list(toUnitsName,toUnitsList);
-    RpUnits::units2list(fromUnitsName,fromUnitsList);
-
+    RpUnits::units2list(fromUnitsName,fromUnitsList,type);
+    RpUnits::units2list(toUnitsName,toUnitsList,type);
+
+    fromIter = fromUnitsList.begin();
     toIter = toUnitsList.begin();
 
-    // pass 1: compare basis' of objects to find intra-basis conversions
     while ( toIter != toUnitsList.end() ) {
-        rv = RpUnits::compareListEntryBasis(fromUnitsList, fromIter, toIter);
-        if (rv == 0) {
-
-            // check the names of the units provided by the user
-            // if the names are the same, no need to do a conversion
-            if (fromIter->name() != toIter->name()) {
-
-                // do an intra-basis conversion
-                toUnits = toIter->getUnitsObj();
-                fromUnits = fromIter->getUnitsObj();
-
-                // do conversions
-                factor = 1;
-                factor = fromUnits->convert(toUnits, factor, &convResult);
-                numVal *= pow(factor,toIter->getExponent());
-            }
-
+        fromUnits = fromIter->getUnitsObj();
+        toUnits = toIter->getUnitsObj();
+
+        cList.clear();
+        convResult = fromUnits->getConvertFxnList(toUnits, cList);
+
+        if (convResult == 0) {
+
+            toExp = toIter->getExponent();
+            fromExp = fromIter->getExponent();
+
+            if (fromExp == toExp) {
+                copies = fromExp;
+                if (fromExp < 0) {
+                    copies = copies * -1.00;
+                    totalConvList.push_back(&invert);
+                }
+                while (copies > 0) {
+                    combineLists(totalConvList,cList);
+                    copies--;
+                }
+                if (fromExp < 0) {
+                    totalConvList.push_back(&invert);
+                }
+            }
+            else {
+                // currently we cannot handle conversions of
+                // units where the exponents are different
+                convResult++;
+            }
+
+        }
+
+        if (convResult == 0) {
+            // successful conversion reported
             // remove the elements from the lists
             tempIter = toIter;
-            toIter = toUnitsList.erase(tempIter);
-//            toUnitsList.erase(tempIter);
-//            toIter++;
+            toIter++;
+            toUnitsList.erase(tempIter);
 
             tempIter = fromIter;
             fromUnitsList.erase(tempIter);
+            fromIter = fromUnitsList.begin();
         }
         else {
-            // this is not an intra-basis conversion.
-            // move onto the next toIter
-            toIter++;
-        }
-    }
-
-    toIter = toUnitsList.begin();
-    fromIter = fromUnitsList.begin();
-
-    // pass 2: look for inter-basis conversions
+            // no conversion available?
+            fromIter++;
+            if (fromIter == fromUnitsList.end()) {
+                fromIter = fromUnitsList.begin();
+                // raise error that there was an 
+                // unrecognized conversion request
+                tempIter = toIter;
+                toIter++;
+                toUnitsList.erase(tempIter);
+            }
+        }
+
+    }
+
     if (fromIter != fromUnitsList.end()) {
-        // double while loop to compare each toIter with each fromIter.
-        // the outter while checks the toIter and the inner while
-        // which is conveniently hidden, adjusts the fromIter and toIter
-        // (at the bottom in the else statement).
-        while (toIter != toUnitsList.end()) {
-
-            toUnits = toIter->getUnitsObj();
-            fromUnits = fromIter->getUnitsObj();
-
-            // do an inter-basis conversion...the slow way
-            // there has to be a better way to do this...
-            convResult = 1;
-
-            // in order to convert, exponents must be equal.
-            fromExp = fromIter->getExponent();
-            toExp   = toIter->getExponent();
-
-            if (fromExp == toExp) {
-                if (toExp == 1) {
-                    numVal = fromUnits->convert(toUnits, numVal, &convResult);
-                }
-                else {
-                    factor = 1;
-                    factor = fromUnits->convert(toUnits, factor, &convResult);
-                    numVal *= pow(factor,toExp);
-                }
-            }
-
-            if (convResult == 0) {
-                // successful conversion reported
-                // remove the elements from the lists
-                tempIter = toIter;
-                toUnitsList.erase(tempIter);
-                toIter++;
-
-                tempIter = fromIter;
-                fromUnitsList.erase(tempIter);
-
-                // conversion complete, jump out of the 
-                // while loop
-                break;
-            }
-            else {
-                // conversion was unsuccessful
-                // move onto the next fromIter
-                fromIter++;
-                if (fromIter == fromUnitsList.end()) {
-                    // this is not an inter-basis conversion.
-                    // move onto the next toIter
-                    fromIter = fromUnitsList.begin();
-                    toIter++;
-                }
-            } // end unsuccessful conversion
-        } // end toIter while loop
-    } // end
+        // raise error that there was an
+        // unrecognized conversion request
+    }
+
+
+    if (convResult == 0) {
+        convResult = applyConversion (&numVal, totalConvList);
+    }
 
 
@@ -1623 +1682 @@
 
 /**********************************************************************/
+// METHOD: getConvertFxnList()
+/// Return list of fxn pointers for converting two simple RpUnits objects.
+/**
+ * Return the conversion list that will convert from this RpUnits
+ * object to the provided toUnits object if the conversion is defined
+ * example
+ *      cm.getConvertFxnList(meter,cList)
+ *      cm.getConvertFxnList(angstrum,cList)
+ *
+ * Returns a list of conversion objects, represented by cList,
+ * on success that a value can be applied to. The return value
+ * will be zero (0).
+ * Returns non-zero value on failure.
+ */
+
+int
+RpUnits::getConvertFxnList(const RpUnits* toUnit, convertList& cList) const {
+
+    // currently we convert this object to its basis and look for the
+    // connection to the toUnit object from the basis.
+
+    const RpUnits* toBasis = toUnit->getBasis();
+    const RpUnits* fromUnit = this;
+    const RpUnits* dictToUnit = NULL;
+    convEntry *p;
+    int result = 0;
+
+    // guard against converting to the units you are converting from...
+    // ie. meters->meters
+    if (this->getUnitsName() == toUnit->getUnitsName()) {
+        return result;
+    }
+
+    // convert unit to the basis
+    // makeBasis(&value);
+    // trying to avoid the recursive way of converting to the basis.
+    // need to rethink this.
+    //
+    if ( (basis) && (basis->getUnitsName() != toUnit->getUnitsName()) ) {
+        result = fromUnit->getConvertFxnList(basis,cList);
+        if (result == 0) {
+            fromUnit = basis;
+        }
+        else {
+            // exit because an error occured while
+            // trying to convert to the basis
+            return result;
+        }
+    }
+
+    // find the toUnit in our dictionary.
+    // if the toUnits has a basis, we need to search for the basis
+    // and convert between basis' and then convert again back to the 
+    // original unit.
+    if ( (toBasis) && (toBasis->getUnitsName() != fromUnit->getUnitsName()) ) {
+        dictToUnit = find(toBasis->getUnitsName());
+    }
+    else {
+        dictToUnit = find(toUnit->getUnitsName());
+    }
+
+    // did we find the unit in the dictionary?
+    if (dictToUnit == NULL) {
+        // toUnit was not found in the dictionary
+        result = 1;
+        return result;
+    }
+
+    // search through the conversion list to find
+    // the conversion to the toUnit.
+
+    if (basis) {
+        p = basis->convList;
+    }
+    else {
+        p = this->convList;
+    }
+
+    if (p == NULL) {
+        // there are no conversions
+        result = 1;
+        return result;
+    }
+
+    // loop through our conversion list looking for the correct conversion
+    do {
+
+        if ( (p->conv->toPtr == dictToUnit) && (p->conv->fromPtr == fromUnit) ) {
+            // we found our conversion
+            // call the function pointer with value
+
+            // this should probably be re thought out
+            // the problem is that convForwFxnPtr has the conversion for a
+            // one arg conv function pointer and convForwFxnPtrDD has the
+            // conversion for a two arg conv function pointer
+            // need to make this simpler, more logical maybe only allow 2 arg
+            if (       (p->conv->convForwFxnPtr)
+                    && (! p->conv->convForwFxnPtrDD) ) {
+
+                // value = p->conv->convForwFxnPtr(value);
+                cList.push_back(p->conv->convForwFxnPtr);
+            }
+            /*
+            else if (  (p->conv->convForwFxnPtrDD)
+                    && (! p->conv->convForwFxnPtr) ) {
+
+                // value = p->conv->convForwFxnPtrDD(value, fromUnit->getExponent());
+                cList.pushback(conv);
+            }
+            */
+
+            // check to see if we converted to the actual requested unit
+            // or to the requested unit's basis.
+            // if we converted to the requested unit's basis. we need to
+            // do one last conversion from the requested unit's basis back 
+            // to the requested unit.
+            if ( (toBasis) && (toBasis->getUnitsName() != fromUnit->getUnitsName()) ) {
+                result += toBasis->getConvertFxnList(toUnit,cList);
+            }
+
+            break;
+        }
+
+        if ( (p->conv->toPtr == fromUnit) && (p->conv->fromPtr == dictToUnit) ) {
+            // we found our conversion
+            // call the function pointer with value
+
+            // this should probably be re thought out
+            // the problem is that convForwFxnPtr has the conversion for a
+            // one arg conv function pointer and convForwFxnPtrDD has the
+            // conversion for a two arg conv function pointer
+            // need to make this simpler, more logical maybe only allow 2 arg
+            if (       (p->conv->convBackFxnPtr) 
+                    && (! p->conv->convBackFxnPtrDD) ) {
+
+                // value = p->conv->convBackFxnPtr(value);
+                cList.push_back(p->conv->convBackFxnPtr);
+            }
+            /*
+            else if (  (p->conv->convBackFxnPtrDD)
+                    && (! p->conv->convBackFxnPtr) ) {
+
+                // value = p->conv->convBackFxnPtrDD(value, fromUnit->getExponent());
+                cList.pushback(conv);
+            }
+            */
+
+            // check to see if we converted to the actual requested unit
+            // or to the requested unit's basis.
+            // if we converted to the requested unit's basis. we need to
+            // do one last conversion from the requested unit's basis back 
+            // to the requested unit.
+            if ( (toBasis) && (toBasis->getUnitsName() != fromUnit->getUnitsName()) ) {
+                result += toBasis->getConvertFxnList(toUnit,cList);
+            }
+
+            break;
+        }
+
+        p = p->next;
+
+    } while (p != NULL);
+
+
+    if ( p == NULL) {
+        // we did not find the conversion
+        result += 1;
+    }
+
+    // return the converted value and result flag
+    return result;
+}
+
+/**********************************************************************/
+// METHOD: applyConversion()
+/// Apply a list of conversions in cList to the value val
+/**
+ * Apply a list of conversions, represented by cList, to the value
+ * val.
+ *
+ * Returns an integer value of zero (0) on success
+ * Returns non-zero value on failure.
+ */
+
+int
+RpUnits::applyConversion(double* val, convertList& cList) {
+
+    convertList::iterator iter;
+
+    if(val == NULL) {
+        return 1;
+    }
+
+    for(iter = cList.begin(); iter != cList.end(); iter++)
+    {
+        *val = (*iter)(*val);
+    }
+
+    return 0;
+}
+
+/**********************************************************************/
+// METHOD: combineLists()
+/// combine two convertLists in an orderly fasion
+/**
+ *
+ * elements of l2 are pushed onto l1 in the same order in which it
+ * exists in l2. l1 is changed in this function.
+ *
+ * Returns an integer value of zero (0) on success
+ * Returns non-zero value on failure.
+ */
+
+int
+RpUnits::combineLists(convertList& l1, convertList& l2) {
+
+    for (convertList::iterator iter = l2.begin(); iter != l2.end(); iter++) {
+        l1.push_back(*iter);
+    }
+    return 0;
+
+}
+
+/**********************************************************************/
+// METHOD: printList()
+/// print a list
+/**
+ *
+ * elements of l2 are pushed onto l1 in the same order in which it
+ * exists in l2. l1 is changed in this function.
+ *
+ * Returns an integer value of zero (0) on success
+ * Returns non-zero value on failure.
+ */
+
+int
+RpUnits::printList(convertList& l1) {
+
+    for (convertList::iterator iter = l1.begin(); iter != l1.end(); iter++) {
+        printf("%x\n", int((*iter)));
+    }
+    return 0;
+
+}
+
+/**********************************************************************/
 // METHOD: insert()
 /// Place an RpUnits Object into the Rappture Units Dictionary.
@@ -1660 +1965 @@
 
         p->next = new convEntry (conv,p,NULL);
+    }
+
+}
+
+/**********************************************************************/
+// METHOD: connectIncarnation()
+/// Attach incarnation object information to a RpUnits Object.
+/**
+ */
+
+void
+RpUnits::connectIncarnation(const RpUnits* unit) const {
+
+    incarnationEntry* p = incarnationList;
+
+    if (p == NULL) {
+        incarnationList = new incarnationEntry (unit,NULL,NULL);
+    }
+    else {
+        while (p->next != NULL) {
+            p = p->next;
+        }
+
+        p->next = new incarnationEntry (unit,p,NULL);
     }
 
@@ -1729 +2058 @@
     result += addPresetMass();
     result += addPresetPressure();
+    result += addPresetConcentration();
     result += addPresetMisc();
 
@@ -1796 +2126 @@
     RpUnits::define(fahrenheit, kelvin, fahrenheit2kelvin, kelvin2fahrenheit);
     RpUnits::define(rankine, kelvin, rankine2kelvin, kelvin2rankine);
+    RpUnits::define(fahrenheit, rankine, fahrenheit2rankine, rankine2fahrenheit);
+    RpUnits::define(celcius, rankine, celcius2rankine, rankine2celcius);
 
     return 0;
@@ -1820 +2152 @@
     RpUnits* angstrom   = RpUnits::define("A", NULL, RP_TYPE_LENGTH);
     RpUnits* inch       = RpUnits::define("in", NULL, RP_TYPE_LENGTH);
-    RpUnits* feet       = RpUnits::define("ft", NULL, RP_TYPE_LENGTH);
-    RpUnits* yard       = RpUnits::define("yd", NULL, RP_TYPE_LENGTH);
+    RpUnits* feet       = RpUnits::define("ft", inch, RP_TYPE_LENGTH);
+    RpUnits* yard       = RpUnits::define("yd", inch, RP_TYPE_LENGTH);
 
     RpUnits::makeMetric(meters);
@@ -1827 +2159 @@
     // add length definitions
     RpUnits::define(angstrom, meters, angstrom2meter, meter2angstrom);
+    RpUnits::define(inch, feet, inch2feet, feet2inch);
+    RpUnits::define(inch, yard, inch2yard, yard2inch);
     RpUnits::define(inch, meters, inch2meter, meter2inch);
-    RpUnits::define(feet, meters, feet2meter, meter2feet);
-    RpUnits::define(yard, meters, yard2meter, meter2yard);
 
     return 0;
@@ -1839 +2171 @@
 /**
  * Defines the following units:
- *   volt          (V)
  *   electron Volt (eV)
  *   joule         (J)
@@ -1849 +2180 @@
 RpUnitsPreset::addPresetEnergy () {
 
-    RpUnits* volt       = RpUnits::define("V", NULL, RP_TYPE_ENERGY);
     RpUnits* eVolt      = RpUnits::define("eV", NULL, RP_TYPE_ENERGY);
     RpUnits* joule      = RpUnits::define("J", NULL, RP_TYPE_ENERGY);
 
-    RpUnits::makeMetric(volt);
     RpUnits::makeMetric(eVolt);
     RpUnits::makeMetric(joule);
@@ -1870 +2199 @@
  *   cubic feet (ft3)
  *   us gallons (gal)
+ *   liter      (L)
  *
  * Return codes: 0 success, anything else is error
@@ -1877 +2207 @@
 RpUnitsPreset::addPresetVolume () {
 
-    RpUnits* cubic_meter  = RpUnits::define("m3", NULL, RP_TYPE_VOLUME);
-    // RpUnits* pcubic_meter  = RpUnits::define("/m3", NULL, RP_TYPE_VOLUME);
-    RpUnits* cubic_feet   = RpUnits::define("ft3", NULL, RP_TYPE_VOLUME);
+    // RpUnits* cubic_meter  = RpUnits::define("m3", NULL, RP_TYPE_VOLUME);
+    // RpUnits* cubic_feet   = RpUnits::define("ft3", NULL, RP_TYPE_VOLUME);
     RpUnits* us_gallon    = RpUnits::define("gal", NULL, RP_TYPE_VOLUME);
-
-    RpUnits::makeMetric(cubic_meter);
-
-    // add energy definitions
-    RpUnits::define(cubic_meter,cubic_feet,meter2feet,feet2meter);
-    RpUnits::define(cubic_meter,us_gallon,cubicMeter2usGallon,usGallon2cubicMeter);
-    RpUnits::define(cubic_feet,us_gallon,cubicFeet2usGallon,usGallon2cubicFeet);
+    RpUnits* liter        = RpUnits::define("L", NULL, RP_TYPE_VOLUME);
+
+    /*
+    // RpUnits::makeMetric(cubic_meter);
+    const RpUnits* meter = NULL;
+    const RpUnits* foot = NULL;
+
+    meter = RpUnits::find("m");
+    if (meter && cubic_meter) {
+        RpUnits::incarnate(meter,cubic_meter);
+    }
+    else {
+        // raise an error, could not find meter unit
+    }
+
+    foot = RpUnits::find("ft");
+    if (foot && cubic_feet) {
+        RpUnits::incarnate(foot,cubic_feet);
+    }
+    else {
+        // raise an error, could not find meter unit
+    }
+    */
+
+    RpUnits::makeMetric(liter);
+
+
+    // add volume definitions
+    // RpUnits::define(cubic_meter,cubic_feet,meter2feet,feet2meter);
+    // RpUnits::define(cubic_meter,us_gallon,cubicMeter2usGallon,usGallon2cubicMeter);
+    // RpUnits::define(cubic_feet,us_gallon,cubicFeet2usGallon,usGallon2cubicFeet);
+    // RpUnits::define(cubic_meter,liter,cubicMeter2liter,liter2cubicMeter);
+    // RpUnits::define(liter,us_gallon,liter2us_gallon,us_gallon2liter);
 
     return 0;
@@ -1939 +2294 @@
 
     // add mass definitions
-    // RpUnits::define(radian,gradian,rad2grad,grad2rad);
 
     return 0;
@@ -1951 +2305 @@
  *
  * Defines the following units:
+ *   atmosphere             (atm)
  *   bar                    (bar)
  *   pascal                 (Pa)
@@ -1985 +2340 @@
     RpUnits::define(torr,atmosphere,torr2atm,atm2torr);
     RpUnits::define(torr,psi,torr2psi,psi2torr);
+    RpUnits::define(atmosphere,psi,atm2psi,psi2atm);
 
     RpUnits::define(torr,mmHg,torr2mmHg,mmHg2torr);
+
+    return 0;
+}
+
+/**********************************************************************/
+// METHOD: addPresetConcentration()
+/// Add concentration related units to the dictionary
+/**
+ * http://www.ilpi.com/msds/ref/pressureunits.html
+ *
+ * Defines the following units:
+ *   pH    (pH)
+ *   pOH    (pOH)
+ *
+ * Return codes: 0 success, anything else is error
+ */
+
+int
+RpUnitsPreset::addPresetConcentration () {
+
+    RpUnits* pH  = RpUnits::define("pH",  NULL, RP_TYPE_CONC);
+    RpUnits* pOH = RpUnits::define("pOH",  NULL, RP_TYPE_CONC);
+
+    // add concentration definitions
+    RpUnits::define(pH,pOH,pH2pOH,pOH2pH);
 
     return 0;
@@ -2004 +2385 @@
 RpUnitsPreset::addPresetMisc () {
 
-    RpUnits* mole  = RpUnits::define("mol",  NULL, RP_TYPE_MISC);
-    RpUnits* hertz = RpUnits::define("Hz",  NULL, RP_TYPE_MISC);
+    RpUnits* volt      = RpUnits::define("V", NULL, RP_TYPE_ENERGY);
+    RpUnits* mole      = RpUnits::define("mol",  NULL, RP_TYPE_MISC);
+    RpUnits* hertz     = RpUnits::define("Hz",  NULL, RP_TYPE_MISC);
     RpUnits* becquerel = RpUnits::define("Bq",  NULL, RP_TYPE_MISC);
 
+    RpUnits::makeMetric(volt);
     RpUnits::makeMetric(mole);
     RpUnits::makeMetric(hertz);

trunk/src/core/RpUnits.h

@@ -38 +38 @@
 #define RP_TYPE_MASS        "mass"
 #define RP_TYPE_PRESSURE    "pressure"
+#define RP_TYPE_CONC        "concentration"
 #define RP_TYPE_MISC        "misc"
 
@@ -66 +67 @@
         static int addPresetMass();
         static int addPresetPressure();
+        static int addPresetConcentration();
         static int addPresetMisc();
 };
@@ -229 +231 @@
 };
 
+// used by the RpUnits class to create a linked list of the incarnated units
+// associated with the specific unit.
+//
+// we could templitize this and make a generic linked list
+// or could use generic linked list class from book programming with objects
+//
+class incarnationEntry
+{
+
+    public:
+
+        friend class RpUnits;
+
+        virtual ~incarnationEntry()
+        {}
+
+    private:
+
+        const RpUnits* unit;
+        incarnationEntry*  prev;
+        incarnationEntry*  next;
+
+        incarnationEntry (
+                const RpUnits* unit,
+                incarnationEntry*  prev,
+                incarnationEntry*  next
+             )
+            :   unit    (unit),
+                prev    (prev),
+                next    (next)
+            {};
+
+};
+
 class RpUnitsListEntry
 {
@@ -324 +360 @@
                                 int* result = NULL  ) const;
 
+        static std::string convert1 ( std::string val,
+                                     std::string toUnits,
+                                     int showUnits,
+                                     int* result = NULL );
+
         static std::string convert ( std::string val,
                                      std::string toUnits,
@@ -386 +427 @@
                                 void* convBackData);
 
+        static int incarnate (  const RpUnits* abstraction,
+                                const RpUnits* entity);
 
         // populate the dictionary with a set of units specified by group
-        // if group equals......................then load................
-        //      "all"                       load all available units
-        //      "energy"                    load units related to energy
-        //      "length"                    load units related to length
-        //      "temp"                      load units related to temperature
-        //      "time"                      load units related to time
-        //      "volume"                    load units related to volume
-        //      "angle"                     load units related to angles
+        // if group equals........................then load................
+        //                   "all"           load all available units
+        //  RP_TYPE_ENERGY   "energy"        load units related to energy
+        //  RP_TYPE_LENGTH   "length"        load units related to length
+        //  RP_TYPE_TEMP     "temperature"   load units related to temperature
+        //  RP_TYPE_TIME     "time"          load units related to time
+        //  RP_TYPE_VOLUME   "volume"        load units related to volume
+        //  RP_TYPE_ANGLE    "angle"         load units related to angles
+        //  RP_TYPE_MASS     "mass"          load units related to mass
+        //  RP_TYPE_PRESSURE "pressure"      load units related to pressure
+        //  RP_TYPE_CONC     "concentration" load units related to pressure
+        //  RP_TYPE_MISC     "misc"          load units related to everything else
         //  (no other groups have been created)
 
@@ -423 +470 @@
             convEntry* curr = NULL;
 
+            incarnationEntry* r = NULL;
+            incarnationEntry* rcurr = NULL;
+
             dict = other.dict;
 
@@ -435 +485 @@
                 }
             }
+
+            if (other.incarnationList) {
+                r = other.incarnationList;
+                incarnationList = new incarnationEntry (r->unit,NULL,NULL);
+                rcurr = incarnationList;
+                while (r->next) {
+                    r = r->next;
+                    rcurr->next = new incarnationEntry (r->unit,rcurr,NULL);
+                    rcurr = rcurr->next;
+                }
+            }
+
         }
 
@@ -442 +504 @@
             convEntry* q = NULL;
             convEntry* curr = NULL;
+
+            incarnationEntry* r = NULL;
+            incarnationEntry* rcurr = NULL;
 
             if ( this != &other ) {
@@ -464 +529 @@
             }
 
+            if (other.incarnationList) {
+                r = other.incarnationList;
+                incarnationList = new incarnationEntry (r->unit,NULL,NULL);
+                rcurr = incarnationList;
+                while (r->next) {
+                    r = r->next;
+                    rcurr->next = new incarnationEntry (r->unit,rcurr,NULL);
+                    rcurr = rcurr->next;
+                }
+            }
+
             return *this;
         }
@@ -479 +555 @@
             convEntry* tmp = p;
 
+            incarnationEntry* r = incarnationList;
+            incarnationEntry* rtmp = r;
+
             while (p != NULL) {
                 tmp = p;
                 p = p->next;
                 delete tmp;
+            }
+
+            while (p != NULL) {
+                rtmp = r;
+                r = r->next;
+                delete rtmp;
             }
         }
@@ -513 +598 @@
         mutable convEntry* convList;
 
+        // linked list of incarnation units for this RpUnit
+        // its mutable because the connectIncarnation function takes in a
+        // const RpUnits* and attempts to change the incarnationList variable
+        // within the RpUnits Object
+        mutable incarnationEntry* incarnationList;
+
 
         // dictionary to store the units.
@@ -535 +626 @@
                 basis       (basis),
                 type        (type),
-                convList    (NULL)
+                convList    (NULL),
+                incarnationList (NULL)
         {};
 
@@ -544 +636 @@
 
         typedef std::list<LIST_TEMPLATE> RpUnitsList;
+        typedef double (*convFxnPtrD) (double);
+        typedef std::list<convFxnPtrD> convertList;
         typedef RpUnitsList::iterator RpUnitsListIter;
 
@@ -549 +643 @@
 
         static int units2list( const std::string& inUnits,
-                               RpUnitsList& outList         );
+                               RpUnitsList& outList,
+                               std::string& type);
         static int grabExponent(const std::string& inStr, double* exp);
         static int grabUnitString( const std::string& inStr);
@@ -565 +660 @@
 
         void RpUnits::connectConversion(conversion* conv) const;
+        void RpUnits::connectIncarnation(const RpUnits* unit) const;
+
+        // return the conversion object that will convert
+        // from this RpUnits to the proovided toUnits object
+        // if the conversion is defined
+        int getConvertFxnList (const RpUnits* toUnits, convertList& cList) const;
+        static int applyConversion (double* val, convertList& cList);
+        static int combineLists (convertList& l1, convertList& l2);
+        static int printList (convertList& l1);
 
 };

trunk/src/core/RpUnitsStd.cc

@@ -14 +14 @@
 #endif
 
+double invert (double inVal)
+{
+    return (1.0/inVal);
+}
+
 /****************************************
  * METRIC CONVERSIONS
@@ -19 +24 @@
 
 
+double deci2base (double deci)
+{
+   return deci*1e-1;
+}
+
 double centi2base (double centi)
 {
@@ -54 +64 @@
 }
 
+double deca2base (double deca)
+{
+    return deca*1e1;
+}
+
+double hecto2base (double hecto)
+{
+    return hecto*1e2;
+}
+
 double kilo2base (double kilo)
 {
@@ -79 +99 @@
 }
 
+double exa2base (double exa)
+{
+    return exa*1e18;
+}
+
+double base2deci (double base)
+{
+    return base*1e1;
+}
+
 double base2centi (double base)
 {
@@ -114 +144 @@
 }
 
+double base2deca (double base)
+{
+    return base*1e-1;
+}
+
+double base2hecto (double base)
+{
+    return base*1e-2;
+}
+
 double base2kilo (double base)
 {
@@ -137 +177 @@
 {
     return base*1e-15;
+}
+
+double base2exa (double base)
+{
+    return base*1e-18;
 }
 
@@ -160 +205 @@
 }
 
-double inch2meter (double in)
-{
-    return (in/(39.37008));
-}
-
-double meter2feet (double meter)
-{
-    return (meter*(3.280840));
-}
-
-double feet2meter (double ft)
-{
-    return (ft/(3.280840));
-}
-
-double meter2yard (double meter)
-{
-    return (meter*(1.093613));
-}
-
-double yard2meter (double yd)
-{
-    return (yd/(1.093613));
+double inch2meter (double inch)
+{
+    return (inch/(39.37008));
+}
+
+double inch2feet (double inch)
+{
+    return (inch/(12.00));
+}
+
+double feet2inch (double ft)
+{
+    return (ft*(12.00));
+}
+
+double inch2yard (double inch)
+{
+    return (inch/(36.00));
+}
+
+double yard2inch (double yd)
+{
+    return (yd*(36.00));
 }
 
@@ -211 +256 @@
 double rankine2kelvin (double R)
 {
-    return ((9.0/5.0)*R);
+    return ((5.0/9.0)*R);
 }
 
 double kelvin2rankine (double K)
 {
-    return ((5.0/9.0)*K);
+    return ((9.0/5.0)*K);
 }
 
@@ -229 +274 @@
 }
 
+double fahrenheit2rankine (double F)
+{
+    return (F+459.67);
+}
+
+double rankine2fahrenheit (double R)
+{
+    return (R-459.67);
+}
+
+double rankine2celcius (double R)
+{
+    return ((R*(5.0/9.0))-273.15);
+}
+
+double celcius2rankine (double C)
+{
+    return ((C + 273.15)*(9.0/5.0));
+}
+
 /****************************************
  * ENERGY CONVERSIONS
@@ -265 +330 @@
 {
     return (gal/7.48051);
+}
+
+double cubicMeter2liter (double m3)
+{
+    return (m3*1e3);
+}
+
+double liter2cubicMeter (double L)
+{
+    return (L*1e-3);
 }
 
@@ -446 +521 @@
 }
 
+double psi2atm (double psi)
+{
+    return (psi*68.046e-3);
+}
+
+double atm2psi (double atm)
+{
+    return (atm*14.696);
+}
+
+/****************************************
+ * CONCENTRATION CONVERSIONS
+ * http://en.wikipedia.org/wiki/PH
+ ****************************************/
+
+double pH2pOH (double pH)
+{
+    // This formula is valid exactly for
+    // temperature = 298.15 K (25 °C) only,
+    // but is acceptable for most lab calculations
+    return (14.00 - pH);
+}
+
+double pOH2pH (double pOH)
+{
+    // This formula is valid exactly for
+    // temperature = 298.15 K (25 °C) only,
+    // but is acceptable for most lab calculations
+    return (14.00 - pOH);
+}
 
 #ifdef __cplusplus

trunk/src/core/RpUnitsStd.h

@@ -12 +12 @@
 #endif
 
+double invert (double inVal);
+
+double deci2base (double deci);
 double centi2base (double centi);
 double milli2base (double milli);
@@ -19 +22 @@
 double femto2base (double femto);
 double atto2base (double atto);
+
+double deca2base (double deca);
+double hecto2base (double hecto);
 double kilo2base (double kilo);
 double mega2base (double mega);
@@ -24 +30 @@
 double tera2base (double tera);
 double peta2base (double peta);
+double exa2base (double exa);
 
 
 
+double base2deci (double base);
 double base2centi (double base);
 double base2milli (double base);
@@ -34 +42 @@
 double base2femto (double base);
 double base2atto (double base);
+
+double base2deca (double base);
+double base2hecto (double base);
 double base2kilo (double base);
 double base2mega (double base);
@@ -39 +50 @@
 double base2tera (double base);
 double base2peta (double base);
+double base2exa (double base);
 
 
@@ -45 +57 @@
 double meter2angstrom (double meter);
 double meter2inch (double meter);
-double inch2meter (double in);
-double meter2feet (double meter);
-double feet2meter (double ft);
-double meter2yard (double meter);
-double yard2meter (double yd);
+double inch2meter (double inch);
+double inch2feet (double inch);
+double feet2inch (double ft);
+double inch2yard (double inch);
+double yard2inch (double yd);
 
 
@@ -62 +74 @@
 double fahrenheit2kelvin (double F);
 double kelvin2fahrenheit (double K);
+double fahrenheit2rankine (double F);
+double rankine2fahrenheit (double R);
+double rankine2celcius (double R);
+double celcius2rankine (double C);
 
 
@@ -75 +91 @@
 double cubicFeet2usGallon (double ft3);
 double usGallon2cubicFeet (double gal);
+double cubicMeter2liter (double m3);
+double liter2cubicMeter (double L);
 
 
@@ -116 +134 @@
 double torr2mmHg (double torr);
 double mmHg2torr (double mmHg);
-double kPa2KPa (double kPa);
-double KPa2kPa (double KPa);
+double psi2atm (double psi);
+double atm2psi (double atm);
 
 
+
+double pH2pOH (double pH);
+double pOH2pH (double pOH);
 
 #ifdef __cplusplus