[115] | 1 | /* |
---|
| 2 | * ====================================================================== |
---|
| 3 | * Copyright (c) 2004-2005 Purdue Research Foundation |
---|
| 4 | * |
---|
| 5 | * See the file "license.terms" for information on usage and |
---|
| 6 | * redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. |
---|
| 7 | * ====================================================================== |
---|
| 8 | */ |
---|
[40] | 9 | #include "RpUnits.h" |
---|
| 10 | |
---|
| 11 | |
---|
| 12 | void success() |
---|
| 13 | { |
---|
| 14 | printf ("Test Successful\n"); |
---|
| 15 | } |
---|
| 16 | |
---|
| 17 | void fail() |
---|
| 18 | { |
---|
| 19 | printf ("Test FAILED !!!!!!!!!!!!!!!!!\n"); |
---|
| 20 | exit(-1); |
---|
| 21 | } |
---|
| 22 | |
---|
| 23 | |
---|
| 24 | int main() |
---|
| 25 | { |
---|
| 26 | double value = 0.0; |
---|
[68] | 27 | std::string strValue; |
---|
[40] | 28 | // int failTest = 0; |
---|
| 29 | int result = 0; |
---|
| 30 | // std::list<double,RpUnits *> |
---|
| 31 | |
---|
| 32 | // |
---|
| 33 | // use main to test class functionality |
---|
| 34 | // |
---|
| 35 | |
---|
| 36 | // test define(units,basis) |
---|
| 37 | // this should create an object of type RpUnits |
---|
| 38 | // with the units of "m" and basis should be NULL |
---|
| 39 | // which tells us that this object represents a fundamental system |
---|
| 40 | // of units |
---|
| 41 | // |
---|
| 42 | printf ("=============== TEST 1 ===============\n"); |
---|
[104] | 43 | const RpUnits * meters = RpUnits::define("m", NULL); |
---|
[40] | 44 | // (meters) ? success() : fail(); |
---|
| 45 | // RpUnits * centimeter = RpUnits::define("cm", NULL); |
---|
| 46 | |
---|
| 47 | RpUnits::makeMetric(meters); |
---|
| 48 | RpUnits::define("V", NULL); |
---|
| 49 | RpUnits::define("s", NULL); |
---|
| 50 | |
---|
| 51 | /* |
---|
| 52 | std::string srch_str = std::string("cm"); |
---|
| 53 | |
---|
| 54 | RpUnits* meters2 = RpUnits::find("cm"); |
---|
| 55 | if (meters2) { |
---|
| 56 | std::cout << "meters2 exists" << std::endl; |
---|
| 57 | std::cout << "meters2 = :" << meters2->getUnitsName() <<":"<< std::endl; |
---|
| 58 | } |
---|
| 59 | |
---|
| 60 | std::cout << "complete"<< std::endl; |
---|
| 61 | |
---|
| 62 | */ |
---|
| 63 | |
---|
[104] | 64 | const RpUnits* mobility = RpUnits::defineCmplx("cm2/Vs", NULL); |
---|
[40] | 65 | std::cout << "mobility = :" << mobility->getUnitsName() <<":"<< std::endl; |
---|
| 66 | |
---|
[104] | 67 | const RpUnits* mobility2 = RpUnits::find("cm2V-1s-1"); |
---|
[40] | 68 | if (mobility2) { |
---|
| 69 | std::cout << "mobility2 exists" << std::endl; |
---|
| 70 | std::cout << "mobility2 = :" << mobility2->getUnits() <<":"<< std::endl; |
---|
| 71 | std::cout << "mobility2 = :" << mobility2->getUnitsName() <<":"<< std::endl; |
---|
| 72 | } |
---|
| 73 | else { |
---|
| 74 | std::cout << "mobility2 dn exists" << std::endl; |
---|
| 75 | } |
---|
| 76 | |
---|
[104] | 77 | const RpUnits* cmeters = RpUnits::find("cm"); |
---|
| 78 | const RpUnits* angstrom = RpUnits::define("A", NULL); |
---|
[40] | 79 | RpUnits::define(angstrom, meters, angstrom2meter, meter2angstrom); |
---|
| 80 | |
---|
| 81 | value = angstrom->convert(meters,1.0,&result); |
---|
| 82 | std::cout << "1 angstrom = " << value << " meters" << std::endl; |
---|
| 83 | |
---|
| 84 | result = 0; |
---|
| 85 | value = cmeters->convert(angstrom,1e-8,&result); |
---|
| 86 | std::cout << "1.0e-8 centimeter = " << value << " angstroms" << std::endl; |
---|
| 87 | |
---|
| 88 | |
---|
[104] | 89 | const RpUnits* fahrenheit = RpUnits::define("F", NULL); |
---|
| 90 | const RpUnits* celcius = RpUnits::define("C", NULL); |
---|
| 91 | const RpUnits* kelvin = RpUnits::define("K", NULL); |
---|
[40] | 92 | |
---|
| 93 | RpUnits::define(fahrenheit, celcius, fahrenheit2centigrade, centigrade2fahrenheit); |
---|
| 94 | RpUnits::define(celcius, kelvin, centigrade2kelvin, kelvin2centigrade); |
---|
| 95 | |
---|
| 96 | value = fahrenheit->convert(celcius,72,&result); |
---|
| 97 | std::cout << "72 degrees fahrenheit = " << value << " degrees celcius" << std::endl; |
---|
| 98 | |
---|
| 99 | value = celcius->convert(fahrenheit,value,&result); |
---|
| 100 | std::cout << "22.222 degrees celcius = " << value << " degrees fahrenheit" << std::endl; |
---|
| 101 | |
---|
| 102 | value = celcius->convert(kelvin,20,&result); |
---|
| 103 | std::cout << "20 degrees celcius = " << value << " kelvin" << std::endl; |
---|
| 104 | |
---|
| 105 | value = kelvin->convert(celcius,300,&result); |
---|
| 106 | std::cout << "300 kelvin = " << value << " degrees celcius" << std::endl; |
---|
| 107 | |
---|
| 108 | /* |
---|
| 109 | // test getUnits() member function of objects of type RpUnits |
---|
| 110 | // this test should return the units of "m" for the oject |
---|
| 111 | // meters |
---|
| 112 | // |
---|
| 113 | printf ("=============== TEST 2 ===============\n"); |
---|
| 114 | (meters->getUnits().c_str()) ? success() : fail(); |
---|
| 115 | printf("meters units = :%s:\n", meters->getUnits().c_str()); |
---|
| 116 | |
---|
| 117 | // test getBasis() functionality of objects of type RpUnits |
---|
| 118 | // create an object of type RpUnits and associate it with the |
---|
| 119 | // meters RpUnits object as its basis. |
---|
| 120 | // print out what it reports its basis is. |
---|
| 121 | // |
---|
| 122 | printf ("=============== TEST 3 ===============\n"); |
---|
| 123 | std::string t3units = "cm"; |
---|
| 124 | // RpUnits * centimeters = RpUnits::define("cm", meters); |
---|
| 125 | RpUnits * centimeters = RpUnits::define(t3units, meters); |
---|
| 126 | (centimeters) ? success() : fail(); |
---|
| 127 | printf("cm units = :%s:\n", centimeters->getUnits().c_str() ); |
---|
| 128 | printf("cm basis = :%s:\n", centimeters->getBasis()->getUnits().c_str() ); |
---|
| 129 | |
---|
| 130 | // test makeBasis() |
---|
| 131 | // |
---|
| 132 | printf ("=============== TEST 4.1 ===============\n"); |
---|
| 133 | // value = centimeters->makeBasis(100.00); |
---|
| 134 | value = 100.00; |
---|
| 135 | failTest = centimeters->makeBasis(&value); |
---|
| 136 | (value == 1 && !failTest) ? success() : fail(); |
---|
| 137 | printf("100 cm = :%f: meters\n", value); |
---|
| 138 | |
---|
| 139 | // test makeBasis() with a list of values, all the same units |
---|
| 140 | // |
---|
| 141 | printf ("=============== TEST 4.2 ===============\n"); |
---|
| 142 | // |
---|
| 143 | // double * valueArr = (double *) calloc(12,sizeof(double)); |
---|
| 144 | // if (!valueArr) { |
---|
| 145 | // // complain that malloc failed |
---|
| 146 | // exit(-2); |
---|
| 147 | // } |
---|
| 148 | // |
---|
| 149 | // valueArr = centimeters->makeBasis(100.00); |
---|
| 150 | // |
---|
| 151 | // (value == 1) ? success() : fail(); |
---|
| 152 | // printf("100 cm = :%f: meters\n", value); |
---|
| 153 | |
---|
| 154 | // test makeBasis() with a list of values, all different units |
---|
| 155 | // |
---|
| 156 | printf ("=============== TEST 4.3 ===============\n"); |
---|
| 157 | // value = centimeters->makeBasis(100.00); |
---|
| 158 | // (value == 1) ? success() : fail(); |
---|
| 159 | // printf("100 cm = :%f: meters\n", value); |
---|
| 160 | |
---|
| 161 | */ |
---|
[73] | 162 | |
---|
[40] | 163 | printf ("=============== TEST 4.4 ===============\n"); |
---|
| 164 | |
---|
[104] | 165 | const RpUnits * millimeter = RpUnits::find("mm"); |
---|
| 166 | const RpUnits * micrometer = RpUnits::find("um"); |
---|
| 167 | const RpUnits * nanometer = RpUnits::find("nm"); |
---|
| 168 | const RpUnits * picometer = RpUnits::find("pm"); |
---|
| 169 | const RpUnits * femtometer = RpUnits::find("fm"); |
---|
| 170 | const RpUnits * attometer = RpUnits::find("am"); |
---|
| 171 | const RpUnits * kilometer = RpUnits::find("km"); |
---|
| 172 | const RpUnits * megameter = RpUnits::find("Mm"); |
---|
| 173 | const RpUnits * gigameter = RpUnits::find("Gm"); |
---|
| 174 | const RpUnits * terameter = RpUnits::find("Tm"); |
---|
| 175 | const RpUnits * petameter = RpUnits::find("Pm"); |
---|
[40] | 176 | |
---|
| 177 | value = 1.0e+3; |
---|
| 178 | millimeter->makeBasis(&value); |
---|
| 179 | (value == 1) ? success() : fail(); |
---|
| 180 | printf("1.0e3 mm = :%f: meters\n", value); |
---|
| 181 | |
---|
| 182 | value = 1.0e+6; |
---|
| 183 | micrometer->makeBasis(&value); |
---|
| 184 | (value == 1) ? success() : fail(); |
---|
| 185 | printf("1.0e6 um = :%f: meters\n", value); |
---|
| 186 | |
---|
| 187 | value = 1.0e+9; |
---|
| 188 | nanometer->makeBasis(&value); |
---|
| 189 | (value == 1) ? success() : fail(); |
---|
| 190 | printf("1.0e9 nm = :%f: meters\n", value); |
---|
| 191 | |
---|
| 192 | value = 1.0e+12; |
---|
| 193 | picometer->makeBasis(&value); |
---|
| 194 | (value == 1) ? success() : fail(); |
---|
| 195 | printf("1.0e12 pm = :%f: meters\n", value); |
---|
| 196 | |
---|
| 197 | value = 1.0e+15; |
---|
| 198 | femtometer->makeBasis(&value); |
---|
| 199 | (value == 1) ? success() : fail(); |
---|
| 200 | printf("1.0e15 fm = :%f: meters\n", value); |
---|
| 201 | |
---|
| 202 | value = 1.0e+18; |
---|
| 203 | attometer->makeBasis(&value); |
---|
| 204 | (value == 1) ? success() : fail(); |
---|
| 205 | printf("1.0e18 am = :%f: meters\n", value); |
---|
| 206 | |
---|
| 207 | value = 1.0e-3; |
---|
| 208 | kilometer->makeBasis(&value); |
---|
| 209 | (value == 1) ? success() : fail(); |
---|
| 210 | printf("1.0e-3 km = :%f: meters\n", value); |
---|
| 211 | |
---|
| 212 | value = 1.0e-6; |
---|
| 213 | megameter->makeBasis(&value); |
---|
| 214 | (value == 1) ? success() : fail(); |
---|
| 215 | printf("1.0e-6 Mm = :%f: meters\n", value); |
---|
| 216 | |
---|
| 217 | value = 1.0e-9; |
---|
| 218 | gigameter->makeBasis(&value); |
---|
| 219 | (value == 1) ? success() : fail(); |
---|
| 220 | printf("1.0e-9 Gm = :%f: meters\n", value); |
---|
| 221 | |
---|
| 222 | value = 1.0e-12; |
---|
| 223 | terameter->makeBasis(&value); |
---|
| 224 | (value == 1) ? success() : fail(); |
---|
| 225 | printf("1.0e-12 Gm = :%f: meters\n", value); |
---|
| 226 | |
---|
| 227 | value = 1.0e-15; |
---|
| 228 | petameter->makeBasis(&value); |
---|
| 229 | (value == 1) ? success() : fail(); |
---|
| 230 | printf("1.0e-15 Pm = :%f: meters\n", value); |
---|
| 231 | |
---|
| 232 | value = 2; |
---|
| 233 | meters->makeBasis(&value); |
---|
| 234 | (value == 2) ? success() : fail(); |
---|
| 235 | printf("2 m = :%f: meters\n", value); |
---|
| 236 | |
---|
[68] | 237 | printf ("=============== TEST 5 ===============\n"); |
---|
[40] | 238 | |
---|
[68] | 239 | strValue = RpUnits::convert("72F","C",1); |
---|
| 240 | std::cout << "result = " << result << std::endl; |
---|
| 241 | std::cout << "strValue convert(72F,C,1) = " << strValue << std::endl; |
---|
| 242 | |
---|
| 243 | strValue = RpUnits::convert("72F","C",0); |
---|
| 244 | std::cout << "result = " << result << std::endl; |
---|
| 245 | std::cout << "strValue convert(72F,C,0) = " << strValue << std::endl; |
---|
| 246 | |
---|
| 247 | strValue = RpUnits::convert("20C","K",1); |
---|
| 248 | std::cout << "result = " << result << std::endl; |
---|
| 249 | std::cout << "strValue convert(20C,K,1) = " << strValue << std::endl; |
---|
| 250 | |
---|
| 251 | strValue = RpUnits::convert("20C","K",0); |
---|
| 252 | std::cout << "result = " << result << std::endl; |
---|
| 253 | std::cout << "strValue convert(20C,K,1) = " << strValue << std::endl; |
---|
| 254 | |
---|
| 255 | strValue = RpUnits::convert("300K","C",1); |
---|
| 256 | std::cout << "result = " << result << std::endl; |
---|
| 257 | std::cout << "strValue convert(300K,C,1) = " << strValue << std::endl; |
---|
| 258 | |
---|
| 259 | strValue = RpUnits::convert("300K","C",0); |
---|
| 260 | std::cout << "result = " << result << std::endl; |
---|
| 261 | std::cout << "strValue convert(300K,C,0) = " << strValue << std::endl; |
---|
| 262 | |
---|
[73] | 263 | |
---|
| 264 | |
---|
| 265 | |
---|
[104] | 266 | const RpUnits* eV = RpUnits::define("eV", NULL); |
---|
| 267 | const RpUnits* joules = RpUnits::define("J", NULL); |
---|
[114] | 268 | |
---|
[73] | 269 | RpUnits::define(eV, joules, electronVolt2joule, joule2electronVolt); |
---|
[114] | 270 | |
---|
[73] | 271 | value = joules->convert(eV,1,&result); |
---|
| 272 | std::cout << "1 joule = " << value << " electronVolts" << std::endl; |
---|
[114] | 273 | |
---|
[73] | 274 | value = eV->convert(joules,1,&result); |
---|
| 275 | std::cout << "1 electronVolt = " << value << " joules" << std::endl; |
---|
[114] | 276 | |
---|
[73] | 277 | strValue = RpUnits::convert("10eV","J",1); |
---|
| 278 | std::cout << "strValue convert(10eV,J,1) = " << strValue << std::endl; |
---|
| 279 | |
---|
| 280 | strValue = RpUnits::convert("1eV","J",0); |
---|
| 281 | std::cout << "strValue convert(1eV,J,0) = " << strValue << std::endl; |
---|
[114] | 282 | |
---|
[73] | 283 | strValue = RpUnits::convert("10J","eV",1); |
---|
| 284 | std::cout << "strValue convert(10J,eV,1) = " << strValue << std::endl; |
---|
| 285 | |
---|
| 286 | strValue = RpUnits::convert("1J","eV",0); |
---|
| 287 | std::cout << "strValue convert(1J,eV,0) = " << strValue << std::endl; |
---|
[114] | 288 | |
---|
| 289 | |
---|
| 290 | |
---|
| 291 | |
---|
| 292 | |
---|
| 293 | |
---|
| 294 | std::cout << "TESTING COPY CONSTRUCTOR" << std::endl; |
---|
| 295 | |
---|
| 296 | RpUnits *origRpUnits = RpUnits::define("obj2", NULL); |
---|
| 297 | RpUnits copyRpUnits = *origRpUnits; |
---|
| 298 | |
---|
| 299 | std::cout << "origRpUnits = " << origRpUnits->getUnitsName() << std::endl; |
---|
| 300 | std::cout << "copyRpUnits = " << copyRpUnits.getUnitsName() << std::endl; |
---|
| 301 | std::cout << "modifying origRpUnits" << std::endl; |
---|
| 302 | delete origRpUnits; |
---|
| 303 | origRpUnits = RpUnits::define("obj3",NULL); |
---|
| 304 | std::cout << "origRpUnits = " << origRpUnits->getUnitsName() << std::endl; |
---|
| 305 | std::cout << "copyRpUnits = " << copyRpUnits.getUnitsName() << std::endl; |
---|
| 306 | std::cout << "deleting origRpUnits" << std::endl; |
---|
| 307 | delete origRpUnits; |
---|
| 308 | std::cout << "copyRpUnits = " << copyRpUnits.getUnitsName() << std::endl; |
---|
| 309 | |
---|
| 310 | std::cout << "TESTING COPY ASSIGNMENT OPERATOR" << std::endl; |
---|
| 311 | |
---|
| 312 | RpUnits *testRpUnits = RpUnits::define("test2", NULL); |
---|
| 313 | copyRpUnits = *testRpUnits; |
---|
| 314 | |
---|
| 315 | std::cout << "testRpUnits = " << testRpUnits->getUnitsName() << std::endl; |
---|
| 316 | std::cout << "copyRpUnits = " << copyRpUnits.getUnitsName() << std::endl; |
---|
| 317 | std::cout << "modifying testRpUnits" << std::endl; |
---|
| 318 | delete testRpUnits; |
---|
| 319 | testRpUnits = RpUnits::define("test3",NULL); |
---|
| 320 | std::cout << "testRpUnits = " << testRpUnits->getUnitsName() << std::endl; |
---|
| 321 | std::cout << "copyRpUnits = " << copyRpUnits.getUnitsName() << std::endl; |
---|
| 322 | std::cout << "deleting testRpUnits" << std::endl; |
---|
| 323 | delete testRpUnits; |
---|
| 324 | std::cout << "copyRpUnits = " << copyRpUnits.getUnitsName() << std::endl; |
---|
[40] | 325 | return 0; |
---|
| 326 | } |
---|