scifir-units 2.0.0
scifir-units is a library of units of measurement, angles, coordinates, fields, and related data, all lightweight, that help in the development of scientific software and scientific machines
Loading...
Searching...
No Matches
dimension.cpp
Go to the documentation of this file.
1#include "./dimension.hpp"
2
3#include "./constants.hpp"
4
5#include "boost/algorithm/string.hpp"
6
7#include "unicode/unistr.h"
8#include "unicode/uchar.h"
9
10#include <cmath>
11#include <iostream>
12#include <numbers>
13#include <set>
14#include <sstream>
15#include <string>
16#include <utility>
17
18using namespace std;
19
20namespace scifir
21{
22 map<string,vector<dimension>> dimension::base_dimensions = map<string,vector<dimension>>();
23 map<int,string> dimension::full_symbols = map<int,string>();
24 int dimension::total_full_symbols = 0;
25 set<string> dimension::prefixes_options {"Q", "R", "Y", "Z", "E", "P", "T", "G", "M", "k", "h", "d", "c", "m", "\u00B5", "u", "n", "p", "f", "a", "z", "y", "r", "q"};
26
27 dimension::dimension() : prefix(),dimension_type(dimension::NONE),dimension_position(dimension::NO_POSITION),symbol()
28 {}
29
30#ifdef IS_UNIX
31 dimension::dimension(const dimension& x) : prefix(x.prefix),dimension_type(x.dimension_type),dimension_position(x.dimension_position)
32 {
33 std::strncpy(symbol, x.symbol, 3);
34 }
35
36 dimension::dimension(dimension&& x) : prefix(std::move(x.prefix)),dimension_type(std::move(x.dimension_type)),dimension_position(std::move(x.dimension_position))
37 {
38 std::strncpy(symbol, std::move(x.symbol), 3);
39 }
40#elif IS_WINDOWS
41 dimension::dimension(const dimension& x) : prefix(x.prefix),dimension_type(x.dimension_type),dimension_position(x.dimension_position)
42 {
43 strncpy_s(symbol, x.symbol, 3);
44 }
45
46 dimension::dimension(dimension&& x) : prefix(std::move(x.prefix)),dimension_type(std::move(x.dimension_type)),dimension_position(std::move(x.dimension_position))
47 {
48 strncpy_s(symbol, std::move(x.symbol), 3);
49 }
50#endif
51
54
57
58 dimension::dimension(const string& init_dimension,dimension::position new_position) : prefix(),dimension_type(dimension::NONE),dimension_position(new_position),symbol()
59 {
60 string dimension_name;
61 string prefix_name;
62 if(dimension::prefixes_options.count(init_dimension.substr(0,1)) and init_dimension != "degree" and init_dimension != "rad" and init_dimension != "sr" and init_dimension != "m" and init_dimension != "Hz" and init_dimension != "Pa" and init_dimension.substr(0,2) != "da" and init_dimension != "°C" and init_dimension.substr(0,3) != "mol" and init_dimension != "cd" and init_dimension != "Ω" and init_dimension != "Ohm" and init_dimension != "ohm" and init_dimension != "T" and init_dimension != "Gy" and init_dimension != "kat" and init_dimension != "Å" and init_dimension != "angstrom" and init_dimension != "min" and init_dimension != "hour" and init_dimension != "day" and init_dimension != "pc" and init_dimension != "amu" and init_dimension != "M" and init_dimension != "particles" and init_dimension != "money" and init_dimension != "px" and init_dimension != "memo" and init_dimension != "mEq" and init_dimension != "dB")
63 {
64 prefix_name = init_dimension.substr(0,1);
65 dimension_name = init_dimension.substr(1);
66 }
67 else if(init_dimension == "day")
68 {
69 prefix_name = "";
70 dimension_name = init_dimension;
71 }
72 else if(init_dimension.substr(0,2) == "da")
73 {
74 prefix_name = "da";
75 dimension_name = init_dimension.substr(2);
76 }
77 else
78 {
79 prefix_name = "";
80 dimension_name = init_dimension;
81 }
82 prefix = scifir::prefix(prefix_name);
83 if(dimension_name == "m")
84 {
85 dimension_type = dimension::METRE;
86 }
87 else if(dimension_name == "degree" or dimension_name == "θ")
88 {
89 dimension_type = dimension::DEGREE;
90 }
91 else if(dimension_name == "rad")
92 {
93 dimension_type = dimension::RADIAN;
94 }
95 else if(dimension_name == "sr")
96 {
97 dimension_type = dimension::STERADIAN;
98 }
99 else if(dimension_name == "s")
100 {
101 dimension_type = dimension::SECOND;
102 }
103 else if(dimension_name == "g")
104 {
105 dimension_type = dimension::GRAM;
106 }
107 else if(dimension_name == "C")
108 {
109 dimension_type = dimension::COULOMB;
110 }
111 else if(dimension_name == "K")
112 {
113 dimension_type = dimension::KELVIN;
114 }
115 else if(dimension_name == "°C")
116 {
117 dimension_type = dimension::CELSIUS;
118 }
119 else if(dimension_name == "mol")
120 {
121 dimension_type = dimension::MOLE;
122 }
123 else if(dimension_name == "cd")
124 {
125 dimension_type = dimension::CANDELA;
126 }
127 else if(dimension_name == "B")
128 {
129 dimension_type = dimension::BYTE;
130 }
131 else if(dimension_name == "bit")
132 {
133 dimension_type = dimension::BIT;
134 }
135 else if(dimension_name == "Hz")
136 {
137 dimension_type = dimension::HERTZ;
138 }
139 else if(dimension_name == "N")
140 {
141 dimension_type = dimension::NEWTON;
142 }
143 else if(dimension_name == "Pa")
144 {
145 dimension_type = dimension::PASCAL;
146 }
147 else if(dimension_name == "J")
148 {
149 dimension_type = dimension::JOULE;
150 }
151 else if(dimension_name == "W")
152 {
153 dimension_type = dimension::WATT;
154 }
155 else if(dimension_name == "A")
156 {
157 dimension_type = dimension::AMPERE;
158 }
159 else if(dimension_name == "V")
160 {
161 dimension_type = dimension::VOLT;
162 }
163 else if(dimension_name == "F")
164 {
165 dimension_type = dimension::FARAD;
166 }
167 else if(dimension_name == "ohm" or dimension_name == "Ohm" or dimension_name == "Ω")
168 {
169 dimension_type = dimension::OHM;
170 }
171 else if(dimension_name == "S")
172 {
173 dimension_type = dimension::SIEMENS;
174 }
175 else if(dimension_name == "Wb")
176 {
177 dimension_type = dimension::WEBER;
178 }
179 else if(dimension_name == "T")
180 {
181 dimension_type = dimension::TESLA;
182 }
183 else if(dimension_name == "H")
184 {
185 dimension_type = dimension::HENRY;
186 }
187 else if(dimension_name == "lm")
188 {
189 dimension_type = dimension::LUMEN;
190 }
191 else if(dimension_name == "lx")
192 {
193 dimension_type = dimension::LUX;
194 }
195 else if(dimension_name == "Bq")
196 {
197 dimension_type = dimension::BECQUEREL;
198 }
199 else if(dimension_name == "Gy")
200 {
201 dimension_type = dimension::GRAY;
202 }
203 else if(dimension_name == "Sv")
204 {
205 dimension_type = dimension::SIEVERT;
206 }
207 else if(dimension_name == "kat")
208 {
209 dimension_type = dimension::KATAL;
210 }
211 else if(dimension_name == "angstrom" or dimension_name == "Å")
212 {
213 dimension_type = dimension::ANGSTROM;
214 }
215 else if(dimension_name == "L")
216 {
217 dimension_type = dimension::LITRE;
218 }
219 else if(dimension_name == "min")
220 {
221 dimension_type = dimension::MINUTE;
222 }
223 else if(dimension_name == "hour")
224 {
225 dimension_type = dimension::HOUR;
226 }
227 else if(dimension_name == "day")
228 {
229 dimension_type = dimension::DAY;
230 }
231 else if(dimension_name == "ly")
232 {
233 dimension_type = dimension::LIGHT_YEAR;
234 }
235 else if(dimension_name == "AU")
236 {
237 dimension_type = dimension::ASTRONOMICAL_UNIT;
238 }
239 else if(dimension_name == "pc")
240 {
241 dimension_type = dimension::PARSEC;
242 }
243 else if(dimension_name == "eV")
244 {
245 dimension_type = dimension::ELECTRON_VOLT;
246 }
247 else if(dimension_name == "Da")
248 {
249 dimension_type = dimension::DALTON;
250 }
251 else if(dimension_name == "amu")
252 {
253 dimension_type = dimension::ATOMIC_MASS_UNIT;
254 }
255 else if(dimension_name == "barn")
256 {
257 dimension_type = dimension::BARN;
258 }
259 else if(dimension_name == "M")
260 {
261 dimension_type = dimension::MOLARITY;
262 }
263 else if(dimension_name == "particles")
264 {
265 dimension_type = dimension::PARTICLES;
266 }
267 else if(dimension_name == "money")
268 {
269 dimension_type = dimension::MONEY;
270 }
271 else if(dimension_name == "px")
272 {
273 dimension_type = dimension::PIXEL;
274 }
275 else if(dimension_name == "memo")
276 {
277 dimension_type = dimension::MEMO;
278 }
279 else if(dimension_name == "IU")
280 {
281 dimension_type = dimension::INTERNATIONAL_UNIT;
282 }
283 else if(dimension_name == "mEq")
284 {
285 dimension_type = dimension::MILLIEQUIVALENT;
286 }
287 else if(dimension_name == "dB")
288 {
289 dimension_type = dimension::DECIBEL;
290 }
291 else if(dimension_name == "")
292 {
293 dimension_type = dimension::NONE;
294 }
295 else
296 {
297 prefix = scifir::prefix(prefix::NONE);
298 if (init_dimension.size() > 2)
299 {
300 string symbol_abreviation = dimension::create_full_symbol(init_dimension);
301#ifdef IS_UNIX
302 std::strncpy(symbol, symbol_abreviation.c_str(), 2);
303#elif IS_WINDOWS
304 strncpy_s(symbol, 3, symbol_abreviation.c_str(), 2);
305#endif
306 dimension_type = dimension::CUSTOM_FULL_SYMBOL;
307 }
308 else
309 {
310#ifdef IS_UNIX
311 std::strncpy(symbol, init_dimension.c_str(), 2);
312#elif IS_WINDOWS
313 strncpy_s(symbol, 3, init_dimension.c_str(), 2);
314#endif
315 dimension_type = dimension::CUSTOM;
316 }
317 }
318 }
319
320#ifdef IS_UNIX
321 dimension& dimension::operator =(const dimension& x)
322 {
323 prefix = x.prefix;
324 dimension_type = x.dimension_type;
325 dimension_position = x.dimension_position;
326 std::strncpy(symbol,x.symbol,3);
327 return *this;
328 }
329
330 dimension& dimension::operator =(dimension&& x)
331 {
332 prefix = std::move(x.prefix);
333 dimension_type = std::move(x.dimension_type);
334 dimension_position = std::move(x.dimension_position);
335 std::strncpy(symbol,std::move(x.symbol),3);
336 return *this;
337 }
338#elif IS_WINDOWS
339 dimension& dimension::operator =(const dimension& x)
340 {
341 prefix = x.prefix;
342 dimension_type = x.dimension_type;
343 dimension_position = x.dimension_position;
344 strncpy_s(symbol,x.symbol,3);
345 return *this;
346 }
347
348 dimension& dimension::operator =(dimension&& x)
349 {
350 prefix = std::move(x.prefix);
351 dimension_type = std::move(x.dimension_type);
352 dimension_position = std::move(x.dimension_position);
353 strncpy_s(symbol,std::move(x.symbol),3);
354 return *this;
355 }
356#endif
357
358 string dimension::get_name() const
359 {
360 switch(dimension_type)
361 {
362 case dimension::NONE:
363 return "empty";
364 case dimension::METRE:
365 return "metre";
366 case dimension::DEGREE:
367 return "degree";
368 case dimension::RADIAN:
369 return "radian";
370 case dimension::STERADIAN:
371 return "steradian";
372 case dimension::SECOND:
373 return "second";
374 case dimension::GRAM:
375 return "gram";
376 case dimension::COULOMB:
377 return "coulomb";
378 case dimension::KELVIN:
379 return "kelvin";
380 case dimension::CELSIUS:
381 return "celsius";
382 case dimension::MOLE:
383 return "mole";
384 case dimension::CANDELA:
385 return "candela";
386 case dimension::BYTE:
387 return "byte";
388 case dimension::BIT:
389 return "bit";
390 case dimension::HERTZ:
391 return "hertz";
392 case dimension::NEWTON:
393 return "newton";
394 case dimension::PASCAL:
395 return "pascal";
396 case dimension::JOULE:
397 return "joule";
398 case dimension::WATT:
399 return "watt";
400 case dimension::AMPERE:
401 return "ampere";
402 case dimension::VOLT:
403 return "volt";
404 case dimension::FARAD:
405 return "farad";
406 case dimension::OHM:
407 return "ohm";
408 case dimension::SIEMENS:
409 return "siemens";
410 case dimension::WEBER:
411 return "weber";
412 case dimension::TESLA:
413 return "tesla";
414 case dimension::HENRY:
415 return "henry";
416 case dimension::LUMEN:
417 return "lumen";
418 case dimension::LUX:
419 return "lux";
420 case dimension::BECQUEREL:
421 return "becquerel";
422 case dimension::GRAY:
423 return "gray";
424 case dimension::SIEVERT:
425 return "sievert";
426 case dimension::KATAL:
427 return "katal";
428 case dimension::ANGSTROM:
429 return "angstrom";
430 case dimension::LITRE:
431 return "litre";
432 case dimension::MINUTE:
433 return "minute";
434 case dimension::HOUR:
435 return "hour";
436 case dimension::DAY:
437 return "day";
438 case dimension::LIGHT_YEAR:
439 return "light year";
440 case dimension::ASTRONOMICAL_UNIT:
441 return "astronomical unit";
442 case dimension::PARSEC:
443 return "parsec";
444 case dimension::ELECTRON_VOLT:
445 return "electron volt";
446 case dimension::DALTON:
447 return "dalton";
448 case dimension::ATOMIC_MASS_UNIT:
449 return "atomic mass unit";
450 case dimension::BARN:
451 return "barn";
452 case dimension::MOLARITY:
453 return "molarity";
454 case dimension::PARTICLES:
455 return "particles";
456 case dimension::CUSTOM:
457 return "custom-dimension";
458 case dimension::CUSTOM_BASIC:
459 return "custom-basic";
460 case dimension::CUSTOM_FULL_SYMBOL:
461 return "custom-full-symbol";
462 case dimension::MONEY:
463 return "money";
464 case dimension::PIXEL:
465 return "pixel";
466 case dimension::MEMO:
467 return "memo";
468 case dimension::INTERNATIONAL_UNIT:
469 return "international-unit";
470 case dimension::MILLIEQUIVALENT:
471 return "milliequivalent";
472 case dimension::DECIBEL:
473 return "decibel";
474 }
475 return "";
476 }
477
478 string dimension::get_fullname() const
479 {
480 return prefix.get_name() + get_name();
481 }
482
483 string dimension::get_plural() const
484 {
485 switch(dimension_type)
486 {
487 case dimension::NONE:
488 return "empty";
489 case dimension::METRE:
490 return "metres";
491 case dimension::DEGREE:
492 return "degrees";
493 case dimension::RADIAN:
494 return "radians";
495 case dimension::STERADIAN:
496 return "steradians";
497 case dimension::SECOND:
498 return "seconds";
499 case dimension::GRAM:
500 return "grams";
501 case dimension::COULOMB:
502 return "coulombs";
503 case dimension::KELVIN:
504 return "kelvins";
505 case dimension::CELSIUS:
506 return "celsius";
507 case dimension::MOLE:
508 return "moles";
509 case dimension::CANDELA:
510 return "candelas";
511 case dimension::BYTE:
512 return "bytes";
513 case dimension::BIT:
514 return "bits";
515 case dimension::HERTZ:
516 return "hertz";
517 case dimension::NEWTON:
518 return "newtons";
519 case dimension::PASCAL:
520 return "pascals";
521 case dimension::JOULE:
522 return "joules";
523 case dimension::WATT:
524 return "watts";
525 case dimension::AMPERE:
526 return "amperes";
527 case dimension::VOLT:
528 return "volts";
529 case dimension::FARAD:
530 return "farads";
531 case dimension::OHM:
532 return "ohms";
533 case dimension::SIEMENS:
534 return "siemens";
535 case dimension::WEBER:
536 return "webers";
537 case dimension::TESLA:
538 return "teslas";
539 case dimension::HENRY:
540 return "henries";
541 case dimension::LUMEN:
542 return "lumens";
543 case dimension::LUX:
544 return "luxes";
545 case dimension::BECQUEREL:
546 return "becquerels";
547 case dimension::GRAY:
548 return "grays";
549 case dimension::SIEVERT:
550 return "sieverts";
551 case dimension::KATAL:
552 return "katals";
553 case dimension::ANGSTROM:
554 return "angstroms";
555 case dimension::LITRE:
556 return "litres";
557 case dimension::MINUTE:
558 return "minutes";
559 case dimension::HOUR:
560 return "hours";
561 case dimension::DAY:
562 return "days";
563 case dimension::LIGHT_YEAR:
564 return "light years";
565 case dimension::ASTRONOMICAL_UNIT:
566 return "astronomical units";
567 case dimension::PARSEC:
568 return "parsecs";
569 case dimension::ELECTRON_VOLT:
570 return "electron volts";
571 case dimension::DALTON:
572 return "daltons";
573 case dimension::ATOMIC_MASS_UNIT:
574 return "atomic mass units";
575 case dimension::BARN:
576 return "barns";
577 case dimension::MOLARITY:
578 return "molarities";
579 case dimension::PARTICLES:
580 return "particles";
581 case dimension::CUSTOM:
582 return "custom-dimension";
583 case dimension::CUSTOM_BASIC:
584 return "custom-basic";
585 case dimension::CUSTOM_FULL_SYMBOL:
586 return "custom-full-symbol";
587 case dimension::MONEY:
588 return "money";
589 case dimension::PIXEL:
590 return "pixels";
591 case dimension::MEMO:
592 return "memos";
593 case dimension::INTERNATIONAL_UNIT:
594 return "international-units";
595 case dimension::MILLIEQUIVALENT:
596 return "milliequivalents";
597 case dimension::DECIBEL:
598 return "decibels";
599 }
600 return "";
601 }
602
603 string dimension::get_fullplural() const
604 {
605 return prefix.get_name() + get_plural();
606 }
607
608 string dimension::get_symbol() const
609 {
610 switch(dimension_type)
611 {
612 case dimension::NONE:
613 return "empty";
614 case dimension::METRE:
615 return "m";
616#ifdef IS_UNIX
617 case dimension::DEGREE:
618 return "θ";
619#elif IS_WINDOWS
620 case dimension::DEGREE:
621 return "θ";
622#endif
623 case dimension::RADIAN:
624 return "rad";
625 case dimension::STERADIAN:
626 return "sr";
627 case dimension::SECOND:
628 return "s";
629 case dimension::GRAM:
630 return "g";
631 case dimension::COULOMB:
632 return "C";
633 case dimension::KELVIN:
634 return "K";
635 case dimension::CELSIUS:
636 return "°C";
637 case dimension::MOLE:
638 return "mol";
639 case dimension::CANDELA:
640 return "cd";
641 case dimension::BYTE:
642 return "B";
643 case dimension::BIT:
644 return "bit";
645 case dimension::HERTZ:
646 return "Hz";
647 case dimension::NEWTON:
648 return "N";
649 case dimension::PASCAL:
650 return "Pa";
651 case dimension::JOULE:
652 return "J";
653 case dimension::WATT:
654 return "W";
655 case dimension::AMPERE:
656 return "A";
657 case dimension::VOLT:
658 return "V";
659 case dimension::FARAD:
660 return "F";
661#ifdef IS_UNIX
662 case dimension::OHM:
663 return "Ω";
664#elif IS_WINDOWS
665 case dimension::OHM:
666 return "Ω";
667#endif
668 case dimension::SIEMENS:
669 return "S";
670 case dimension::WEBER:
671 return "Wb";
672 case dimension::TESLA:
673 return "T";
674 case dimension::HENRY:
675 return "H";
676 case dimension::LUMEN:
677 return "lm";
678 case dimension::LUX:
679 return "lx";
680 case dimension::BECQUEREL:
681 return "Bq";
682 case dimension::GRAY:
683 return "Gy";
684 case dimension::SIEVERT:
685 return "Sv";
686 case dimension::KATAL:
687 return "kat";
688#ifdef IS_UNIX
689 case dimension::ANGSTROM:
690 return "Å";
691#elif IS_WINDOWS
692 case dimension::ANGSTROM:
693 return "Å";
694#endif
695 case dimension::LITRE:
696 return "L";
697 case dimension::MINUTE:
698 return "min";
699 case dimension::HOUR:
700 return "hour";
701 case dimension::DAY:
702 return "day";
703 case dimension::LIGHT_YEAR:
704 return "ly";
705 case dimension::ASTRONOMICAL_UNIT:
706 return "AU";
707 case dimension::PARSEC:
708 return "pc";
709 case dimension::ELECTRON_VOLT:
710 return "eV";
711 case dimension::DALTON:
712 return "Da";
713 case dimension::ATOMIC_MASS_UNIT:
714 return "amu";
715 case dimension::BARN:
716 return "barn";
717 case dimension::MOLARITY:
718 return "M";
719 case dimension::PARTICLES:
720 return "particles";
721 case dimension::CUSTOM:
722 return string("").assign(symbol, symbol + 3);
723 case dimension::CUSTOM_BASIC:
724 return "custom-basic";
725 case dimension::CUSTOM_FULL_SYMBOL:
726 return dimension::get_full_symbol(symbol);
727 case dimension::MONEY:
728 return "money";
729 case dimension::PIXEL:
730 return "px";
731 case dimension::MEMO:
732 return "memo";
733 case dimension::INTERNATIONAL_UNIT:
734 return "IU";
735 case dimension::MILLIEQUIVALENT:
736 return "mEq";
737 case dimension::DECIBEL:
738 return "dB";
739 }
740 return "";
741 }
742
743 long double dimension::get_conversion_factor() const
744 {
745 switch(dimension_type)
746 {
747 case dimension::NONE:
748 return 1.0l;
749 case dimension::METRE:
750 return 1.0l;
751 case dimension::DEGREE:
752 return std::numbers::pi_v<float> / 180.0l;
753 case dimension::RADIAN:
754 return 1.0l;
755 case dimension::STERADIAN:
756 return 1.0l;
757 case dimension::GRAM:
758 return 1.0l;
759 case dimension::SECOND:
760 return 1.0l;
761 case dimension::COULOMB:
762 return 1.0l;
763 case dimension::KELVIN:
764 return 1.0l;
765 case dimension::CELSIUS:
766 return 1.0l;
767 case dimension::MOLE:
768 return 1.0l;
769 case dimension::CANDELA:
770 return 1.0l;
771 case dimension::BYTE:
772 return 1.0l;
773 case dimension::BIT:
774 return 0.125l;
775 case dimension::HERTZ:
776 return 1.0l;
777 case dimension::NEWTON:
778 return 1.0l;
779 case dimension::PASCAL:
780 return 1.0l;
781 case dimension::JOULE:
782 return 1.0l;
783 case dimension::WATT:
784 return 1.0l;
785 case dimension::AMPERE:
786 return 1.0l;
787 case dimension::VOLT:
788 return 1.0l;
789 case dimension::FARAD:
790 return 1;
791 case dimension::OHM:
792 return 1.0l;
793 case dimension::SIEMENS:
794 return 1.0l;
795 case dimension::WEBER:
796 return 1.0l;
797 case dimension::TESLA:
798 return 1.0l;
799 case dimension::HENRY:
800 return 1.0l;
801 case dimension::LUMEN:
802 return 1.0l;
803 case dimension::LUX:
804 return 1.0l;
805 case dimension::BECQUEREL:
806 return 1.0l;
807 case dimension::GRAY:
808 return 1.0l;
809 case dimension::SIEVERT:
810 return 1.0l;
811 case dimension::KATAL:
812 return 1.0l;
813 case dimension::ANGSTROM:
814 return 1.0l;
815 case dimension::LITRE:
816 return 1.0l;
817 case dimension::MINUTE:
818 return 60l;
819 case dimension::HOUR:
820 return 3600l;
821 case dimension::DAY:
822 return 86400l;
823 case dimension::LIGHT_YEAR:
824 return 9.4607379375591e15;
825 case dimension::ASTRONOMICAL_UNIT:
826 return 149597870700.0l;
827 case dimension::PARSEC:
828 return 30856775814913673.0l;
829 case dimension::ELECTRON_VOLT:
830 return 0.0000000000000000001602176634l;
831 case dimension::DALTON:
832 return 0.00000000000000000000000000166053886l;
833 case dimension::ATOMIC_MASS_UNIT:
834 return 0.00000000000000000000000000166053886l;
835 case dimension::BARN:
836 return 0.0000000000000000000000000001l;
837 case dimension::MOLARITY:
838 return 1.0l;
839 case dimension::PARTICLES:
840 return 1.0l/AVOGADRO_CONSTANT;
841 case dimension::CUSTOM:
842 return 1.0l;
843 case dimension::CUSTOM_BASIC:
844 return 1.0l;
845 case dimension::CUSTOM_FULL_SYMBOL:
846 return 1.0l;
847 case dimension::MONEY:
848 return 1.0l;
849 case dimension::PIXEL:
850 return 1.0l;
851 case dimension::MEMO:
852 return 1.0l;
853 case dimension::INTERNATIONAL_UNIT:
854 return 1.0l;
855 case dimension::MILLIEQUIVALENT:
856 return 1.0l;
857 case dimension::DECIBEL:
858 return 1.0l;
859 }
860 return 1.0l;
861 }
862
863 long double dimension::prefix_math() const
864 {
865 return prefix_math(prefix);
866 }
867
868 long double dimension::prefix_math(const scifir::prefix& x_prefix) const
869 {
870 if (dimension_type == dimension::BYTE or dimension_type == dimension::BIT)
871 {
872 return std::pow(1024, x_prefix.get_conversion_factor() / 3);
873 }
874 else
875 {
876 return std::pow(10, x_prefix.get_conversion_factor());
877 }
878 }
879
880 bool dimension::is_simple_dimension() const
881 {
882 switch(dimension_type)
883 {
884 case dimension::NONE:
885 return false;
886 case dimension::METRE:
887 return true;
888 case dimension::DEGREE:
889 return true;
890 case dimension::RADIAN:
891 return true;
892 case dimension::STERADIAN:
893 return true;
894 case dimension::GRAM:
895 return true;
896 case dimension::SECOND:
897 return true;
898 case dimension::COULOMB:
899 return true;
900 case dimension::KELVIN:
901 return true;
902 case dimension::CELSIUS:
903 return true;
904 case dimension::MOLE:
905 return true;
906 case dimension::CANDELA:
907 return true;
908 case dimension::BYTE:
909 return true;
910 case dimension::BIT:
911 return true;
912 case dimension::HERTZ:
913 return true;
914 case dimension::NEWTON:
915 return false;
916 case dimension::PASCAL:
917 return false;
918 case dimension::JOULE:
919 return false;
920 case dimension::WATT:
921 return false;
922 case dimension::AMPERE:
923 return true;
924 case dimension::VOLT:
925 return false;
926 case dimension::FARAD:
927 return false;
928 case dimension::OHM:
929 return false;
930 case dimension::SIEMENS:
931 return false;
932 case dimension::WEBER:
933 return false;
934 case dimension::TESLA:
935 return false;
936 case dimension::HENRY:
937 return false;
938 case dimension::LUMEN:
939 return false;
940 case dimension::LUX:
941 return false;
942 case dimension::BECQUEREL:
943 return true;
944 case dimension::GRAY:
945 return false;
946 case dimension::SIEVERT:
947 return false;
948 case dimension::KATAL:
949 return false;
950 case dimension::ANGSTROM:
951 return true;
952 case dimension::LITRE:
953 return false;
954 case dimension::MINUTE:
955 return true;
956 case dimension::HOUR:
957 return true;
958 case dimension::DAY:
959 return true;
960 case dimension::LIGHT_YEAR:
961 return true;
962 case dimension::ASTRONOMICAL_UNIT:
963 return true;
964 case dimension::PARSEC:
965 return true;
966 case dimension::ELECTRON_VOLT:
967 return false;
968 case dimension::DALTON:
969 return true;
970 case dimension::ATOMIC_MASS_UNIT:
971 return true;
972 case dimension::BARN:
973 return false;
974 case dimension::MOLARITY:
975 return false;
976 case dimension::PARTICLES:
977 return true;
978 case dimension::CUSTOM:
979 return false;
980 case dimension::CUSTOM_BASIC:
981 return true;
982 case dimension::CUSTOM_FULL_SYMBOL:
983 return false;
984 case dimension::MONEY:
985 return true;
986 case dimension::PIXEL:
987 return true;
988 case dimension::MEMO:
989 return true;
990 case dimension::INTERNATIONAL_UNIT:
991 return true;
992 case dimension::MILLIEQUIVALENT:
993 return true;
994 case dimension::DECIBEL:
995 return true;
996 }
997 return false;
998 }
999
1000 bool dimension::is_composite_dimension() const
1001 {
1002 if (dimension_type == dimension::NONE)
1003 {
1004 return false;
1005 }
1006 else
1007 {
1008 return !is_simple_dimension();
1009 }
1010 }
1011
1012 bool dimension::is_base_dimension() const
1013 {
1014 switch(dimension_type)
1015 {
1016 case dimension::NONE:
1017 return false;
1018 case dimension::METRE:
1019 return true;
1020 case dimension::DEGREE:
1021 return false;
1022 case dimension::RADIAN:
1023 return true;
1024 case dimension::STERADIAN:
1025 return true;
1026 case dimension::GRAM:
1027 return true;
1028 case dimension::SECOND:
1029 return true;
1030 case dimension::COULOMB:
1031 return true;
1032 case dimension::KELVIN:
1033 return true;
1034 case dimension::CELSIUS:
1035 return false;
1036 case dimension::MOLE:
1037 return true;
1038 case dimension::CANDELA:
1039 return true;
1040 case dimension::BYTE:
1041 return true;
1042 case dimension::BIT:
1043 return false;
1044 case dimension::HERTZ:
1045 return false;
1046 case dimension::NEWTON:
1047 return false;
1048 case dimension::PASCAL:
1049 return false;
1050 case dimension::JOULE:
1051 return false;
1052 case dimension::WATT:
1053 return false;
1054 case dimension::AMPERE:
1055 return false;
1056 case dimension::VOLT:
1057 return false;
1058 case dimension::FARAD:
1059 return false;
1060 case dimension::OHM:
1061 return false;
1062 case dimension::SIEMENS:
1063 return false;
1064 case dimension::WEBER:
1065 return false;
1066 case dimension::TESLA:
1067 return false;
1068 case dimension::HENRY:
1069 return false;
1070 case dimension::LUMEN:
1071 return false;
1072 case dimension::LUX:
1073 return false;
1074 case dimension::BECQUEREL:
1075 return false;
1076 case dimension::GRAY:
1077 return false;
1078 case dimension::SIEVERT:
1079 return false;
1080 case dimension::KATAL:
1081 return false;
1082 case dimension::ANGSTROM:
1083 return false;
1084 case dimension::LITRE:
1085 return false;
1086 case dimension::MINUTE:
1087 return false;
1088 case dimension::HOUR:
1089 return false;
1090 case dimension::DAY:
1091 return false;
1092 case dimension::LIGHT_YEAR:
1093 return false;
1094 case dimension::ASTRONOMICAL_UNIT:
1095 return false;
1096 case dimension::PARSEC:
1097 return false;
1098 case dimension::ELECTRON_VOLT:
1099 return false;
1100 case dimension::DALTON:
1101 return false;
1102 case dimension::ATOMIC_MASS_UNIT:
1103 return false;
1104 case dimension::BARN:
1105 return false;
1106 case dimension::MOLARITY:
1107 return false;
1108 case dimension::PARTICLES:
1109 return false;
1110 case dimension::CUSTOM:
1111 return false;
1112 case dimension::CUSTOM_BASIC:
1113 return true;
1114 case dimension::CUSTOM_FULL_SYMBOL:
1115 return false;
1116 case dimension::MONEY:
1117 return true;
1118 case dimension::PIXEL:
1119 return true;
1120 case dimension::MEMO:
1121 return true;
1122 case dimension::INTERNATIONAL_UNIT:
1123 return true;
1124 case dimension::MILLIEQUIVALENT:
1125 return true;
1126 case dimension::DECIBEL:
1127 return true;
1128 }
1129 return false;
1130 }
1131
1132 bool dimension::is_derived_dimension() const
1133 {
1134 if (dimension_type == dimension::NONE)
1135 {
1136 return false;
1137 }
1138 else
1139 {
1140 return !is_base_dimension();
1141 }
1142 }
1143
1144 bool dimension::is_SI_base_dimension() const
1145 {
1146 switch(dimension_type)
1147 {
1148 case dimension::NONE:
1149 return false;
1150 case dimension::METRE:
1151 return true;
1152 case dimension::DEGREE:
1153 return false;
1154 case dimension::RADIAN:
1155 return false;
1156 case dimension::STERADIAN:
1157 return false;
1158 case dimension::GRAM:
1159 return true;
1160 case dimension::SECOND:
1161 return true;
1162 case dimension::COULOMB:
1163 return false;
1164 case dimension::KELVIN:
1165 return true;
1166 case dimension::CELSIUS:
1167 return false;
1168 case dimension::MOLE:
1169 return true;
1170 case dimension::CANDELA:
1171 return true;
1172 case dimension::BYTE:
1173 return false;
1174 case dimension::BIT:
1175 return false;
1176 case dimension::HERTZ:
1177 return false;
1178 case dimension::NEWTON:
1179 return false;
1180 case dimension::PASCAL:
1181 return false;
1182 case dimension::JOULE:
1183 return false;
1184 case dimension::WATT:
1185 return false;
1186 case dimension::AMPERE:
1187 return true;
1188 case dimension::VOLT:
1189 return false;
1190 case dimension::FARAD:
1191 return false;
1192 case dimension::OHM:
1193 return false;
1194 case dimension::SIEMENS:
1195 return false;
1196 case dimension::WEBER:
1197 return false;
1198 case dimension::TESLA:
1199 return false;
1200 case dimension::HENRY:
1201 return false;
1202 case dimension::LUMEN:
1203 return false;
1204 case dimension::LUX:
1205 return false;
1206 case dimension::BECQUEREL:
1207 return false;
1208 case dimension::GRAY:
1209 return false;
1210 case dimension::SIEVERT:
1211 return false;
1212 case dimension::KATAL:
1213 return false;
1214 case dimension::ANGSTROM:
1215 return false;
1216 case dimension::LITRE:
1217 return false;
1218 case dimension::MINUTE:
1219 return false;
1220 case dimension::HOUR:
1221 return false;
1222 case dimension::DAY:
1223 return false;
1224 case dimension::LIGHT_YEAR:
1225 return false;
1226 case dimension::ASTRONOMICAL_UNIT:
1227 return false;
1228 case dimension::PARSEC:
1229 return false;
1230 case dimension::ELECTRON_VOLT:
1231 return false;
1232 case dimension::DALTON:
1233 return false;
1234 case dimension::ATOMIC_MASS_UNIT:
1235 return false;
1236 case dimension::BARN:
1237 return false;
1238 case dimension::MOLARITY:
1239 return false;
1240 case dimension::PARTICLES:
1241 return false;
1242 case dimension::CUSTOM:
1243 return false;
1244 case dimension::CUSTOM_BASIC:
1245 return false;
1246 case dimension::CUSTOM_FULL_SYMBOL:
1247 return false;
1248 case dimension::MONEY:
1249 return false;
1250 case dimension::PIXEL:
1251 return false;
1252 case dimension::MEMO:
1253 return false;
1254 case dimension::INTERNATIONAL_UNIT:
1255 return false;
1256 case dimension::MILLIEQUIVALENT:
1257 return false;
1258 case dimension::DECIBEL:
1259 return false;
1260 }
1261 return false;
1262 }
1263
1264 bool dimension::is_SI_derived_dimension() const
1265 {
1266 switch(dimension_type)
1267 {
1268 case dimension::NONE:
1269 return false;
1270 case dimension::METRE:
1271 return false;
1272 case dimension::DEGREE:
1273 return true;
1274 case dimension::RADIAN:
1275 return true;
1276 case dimension::STERADIAN:
1277 return true;
1278 case dimension::GRAM:
1279 return false;
1280 case dimension::SECOND:
1281 return false;
1282 case dimension::COULOMB:
1283 return true;
1284 case dimension::KELVIN:
1285 return false;
1286 case dimension::CELSIUS:
1287 return true;
1288 case dimension::MOLE:
1289 return false;
1290 case dimension::CANDELA:
1291 return false;
1292 case dimension::BYTE:
1293 return false;
1294 case dimension::BIT:
1295 return false;
1296 case dimension::HERTZ:
1297 return true;
1298 case dimension::NEWTON:
1299 return true;
1300 case dimension::PASCAL:
1301 return true;
1302 case dimension::JOULE:
1303 return true;
1304 case dimension::WATT:
1305 return true;
1306 case dimension::AMPERE:
1307 return false;
1308 case dimension::VOLT:
1309 return true;
1310 case dimension::FARAD:
1311 return true;
1312 case dimension::OHM:
1313 return true;
1314 case dimension::SIEMENS:
1315 return true;
1316 case dimension::WEBER:
1317 return true;
1318 case dimension::TESLA:
1319 return true;
1320 case dimension::HENRY:
1321 return true;
1322 case dimension::LUMEN:
1323 return true;
1324 case dimension::LUX:
1325 return true;
1326 case dimension::BECQUEREL:
1327 return true;
1328 case dimension::GRAY:
1329 return true;
1330 case dimension::SIEVERT:
1331 return true;
1332 case dimension::KATAL:
1333 return true;
1334 case dimension::ANGSTROM:
1335 return false;
1336 case dimension::LITRE:
1337 return false;
1338 case dimension::MINUTE:
1339 return false;
1340 case dimension::HOUR:
1341 return false;
1342 case dimension::DAY:
1343 return false;
1344 case dimension::LIGHT_YEAR:
1345 return false;
1346 case dimension::ASTRONOMICAL_UNIT:
1347 return false;
1348 case dimension::PARSEC:
1349 return false;
1350 case dimension::ELECTRON_VOLT:
1351 return false;
1352 case dimension::DALTON:
1353 return false;
1354 case dimension::ATOMIC_MASS_UNIT:
1355 return false;
1356 case dimension::BARN:
1357 return false;
1358 case dimension::MOLARITY:
1359 return false;
1360 case dimension::PARTICLES:
1361 return false;
1362 case dimension::CUSTOM:
1363 return false;
1364 case dimension::CUSTOM_BASIC:
1365 return false;
1366 case dimension::CUSTOM_FULL_SYMBOL:
1367 return false;
1368 case dimension::MONEY:
1369 return false;
1370 case dimension::PIXEL:
1371 return false;
1372 case dimension::MEMO:
1373 return false;
1374 case dimension::INTERNATIONAL_UNIT:
1375 return false;
1376 case dimension::MILLIEQUIVALENT:
1377 return false;
1378 case dimension::DECIBEL:
1379 return false;
1380 }
1381 return false;
1382 }
1383
1384 bool dimension::is_dimensionless() const
1385 {
1386 if (dimension_type == dimension::DEGREE or dimension_type == dimension::RADIAN or dimension_type == dimension::STERADIAN)
1387 {
1388 return true;
1389 }
1390 else
1391 {
1392 return false;
1393 }
1394 }
1395
1396 vector<dimension> dimension::get_base_dimensions() const
1397 {
1398 vector<dimension> basic_dimensions = vector<dimension>();
1399 switch (dimension_type)
1400 {
1401 case dimension::NONE:
1402 basic_dimensions.push_back(dimension(dimension::NONE,prefix::NONE,dimension::NUMERATOR));
1403 break;
1404 case dimension::METRE:
1405 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1406 break;
1407 case dimension::DEGREE:
1408 basic_dimensions.push_back(dimension(dimension::RADIAN,prefix::NONE,dimension::NUMERATOR));
1409 break;
1410 case dimension::RADIAN:
1411 basic_dimensions.push_back(dimension(dimension::RADIAN,prefix::NONE,dimension::NUMERATOR));
1412 break;
1413 case dimension::STERADIAN:
1414 basic_dimensions.push_back(dimension(dimension::STERADIAN,prefix::NONE,dimension::NUMERATOR));
1415 break;
1416 case dimension::SECOND:
1417 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::NUMERATOR));
1418 break;
1419 case dimension::GRAM:
1420 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::NONE,dimension::NUMERATOR));
1421 break;
1422 case dimension::COULOMB:
1423 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1424 break;
1425 case dimension::KELVIN:
1426 basic_dimensions.push_back(dimension(dimension::KELVIN,prefix::NONE,dimension::NUMERATOR));
1427 break;
1428 case dimension::CELSIUS:
1429 basic_dimensions.push_back(dimension(dimension::KELVIN,prefix::NONE,dimension::NUMERATOR));
1430 break;
1431 case dimension::MOLE:
1432 basic_dimensions.push_back(dimension(dimension::MOLE,prefix::NONE,dimension::NUMERATOR));
1433 break;
1434 case dimension::CANDELA:
1435 basic_dimensions.push_back(dimension(dimension::CANDELA,prefix::NONE,dimension::NUMERATOR));
1436 break;
1437 case dimension::BYTE:
1438 basic_dimensions.push_back(dimension(dimension::BYTE,prefix::NONE,dimension::NUMERATOR));
1439 break;
1440 case dimension::BIT:
1441 basic_dimensions.push_back(dimension(dimension::BYTE,prefix::NONE,dimension::NUMERATOR));
1442 break;
1443 case dimension::HERTZ:
1444 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1445 break;
1446 case dimension::NEWTON:
1447 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1448 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1449 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1450 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1451 break;
1452 case dimension::PASCAL:
1453 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1454 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1455 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1456 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::DENOMINATOR));
1457 break;
1458 case dimension::JOULE:
1459 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1460 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1461 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1462 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1463 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1464 break;
1465 case dimension::WATT:
1466 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1467 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1468 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1469 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1470 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1471 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1472 break;
1473 case dimension::AMPERE:
1474 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1475 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1476 break;
1477 case dimension::VOLT:
1478 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1479 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1480 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1481 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1482 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1483 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1484 break;
1485 case dimension::FARAD:
1486 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::DENOMINATOR));
1487 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::DENOMINATOR));
1488 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::DENOMINATOR));
1489 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1490 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1491 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::NUMERATOR));
1492 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::NUMERATOR));
1493 break;
1494 case dimension::OHM:
1495 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1496 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1497 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1498 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1499 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1500 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1501 break;
1502 case dimension::SIEMENS:
1503 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1504 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1505 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::NUMERATOR));
1506 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::DENOMINATOR));
1507 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::DENOMINATOR));
1508 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::DENOMINATOR));
1509 break;
1510 case dimension::WEBER:
1511 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1512 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1513 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1514 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1515 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1516 break;
1517 case dimension::TESLA:
1518 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1519 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1520 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1521 break;
1522 case dimension::HENRY:
1523 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1524 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1525 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1526 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1527 basic_dimensions.push_back(dimension(dimension::COULOMB,prefix::NONE,dimension::NUMERATOR));
1528 break;
1529 case dimension::LUMEN:
1530 basic_dimensions.push_back(dimension(dimension::CANDELA,prefix::NONE,dimension::NUMERATOR));
1531 basic_dimensions.push_back(dimension(dimension::STERADIAN,prefix::NONE,dimension::NUMERATOR));
1532 break;
1533 case dimension::LUX:
1534 basic_dimensions.push_back(dimension(dimension::CANDELA,prefix::NONE,dimension::NUMERATOR));
1535 basic_dimensions.push_back(dimension(dimension::STERADIAN,prefix::NONE,dimension::NUMERATOR));
1536 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::DENOMINATOR));
1537 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::DENOMINATOR));
1538 break;
1539 case dimension::BECQUEREL:
1540 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1541 break;
1542 case dimension::GRAY:
1543 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1544 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1545 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1546 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1547 break;
1548 case dimension::SIEVERT:
1549 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1550 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1551 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1552 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1553 break;
1554 case dimension::KATAL:
1555 basic_dimensions.push_back(dimension(dimension::MOLE,prefix::NONE,dimension::NUMERATOR));
1556 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1557 break;
1558 case dimension::ANGSTROM:
1559 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1560 break;
1561 case dimension::LITRE:
1562 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1563 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1564 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1565 break;
1566 case dimension::MINUTE:
1567 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::NUMERATOR));
1568 break;
1569 case dimension::HOUR:
1570 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::NUMERATOR));
1571 break;
1572 case dimension::DAY:
1573 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::NUMERATOR));
1574 break;
1575 case dimension::LIGHT_YEAR:
1576 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1577 break;
1578 case dimension::ASTRONOMICAL_UNIT:
1579 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1580 break;
1581 case dimension::PARSEC:
1582 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1583 break;
1584 case dimension::ELECTRON_VOLT:
1585 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1586 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1587 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1588 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1589 basic_dimensions.push_back(dimension(dimension::SECOND,prefix::NONE,dimension::DENOMINATOR));
1590 break;
1591 case dimension::DALTON:
1592 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::KILO,dimension::NUMERATOR));
1593 break;
1594 case dimension::ATOMIC_MASS_UNIT:
1595 basic_dimensions.push_back(dimension(dimension::GRAM,prefix::NONE,dimension::NUMERATOR));
1596 break;
1597 case dimension::BARN:
1598 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1599 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR));
1600 break;
1601 case dimension::MOLARITY:
1602 basic_dimensions.push_back(dimension(dimension::MOLE,prefix::NONE,dimension::NUMERATOR));
1603 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::DENOMINATOR));
1604 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::DENOMINATOR));
1605 basic_dimensions.push_back(dimension(dimension::METRE,prefix::NONE,dimension::DENOMINATOR));
1606 break;
1607 case dimension::PARTICLES:
1608 basic_dimensions.push_back(dimension(dimension::MOLE,prefix::NONE,dimension::NUMERATOR));
1609 break;
1610 case dimension::CUSTOM:
1611 {
1612 //return dimension::base_dimensions[symbol];
1613 break;
1614 }
1615 case dimension::CUSTOM_BASIC:
1616 {
1617 basic_dimensions.push_back(*this);
1618 break;
1619 }
1620 case dimension::CUSTOM_FULL_SYMBOL:
1621 {
1622 break;
1623 //return dimension::base_dimensions[dimension::get_full_symbol(symbol)];
1624 }
1625 case dimension::MONEY:
1626 basic_dimensions.push_back(dimension(dimension::MONEY,prefix::NONE,dimension::NUMERATOR));
1627 break;
1628 case dimension::PIXEL:
1629 basic_dimensions.push_back(dimension(dimension::PIXEL,prefix::NONE,dimension::NUMERATOR));
1630 break;
1631 case dimension::MEMO:
1632 basic_dimensions.push_back(dimension(dimension::MEMO,prefix::NONE,dimension::NUMERATOR));
1633 break;
1634 case dimension::INTERNATIONAL_UNIT:
1635 basic_dimensions.push_back(dimension(dimension::INTERNATIONAL_UNIT,prefix::NONE,dimension::NUMERATOR));
1636 break;
1637 case dimension::MILLIEQUIVALENT:
1638 basic_dimensions.push_back(dimension(dimension::MILLIEQUIVALENT,prefix::NONE,dimension::NUMERATOR));
1639 break;
1640 case dimension::DECIBEL:
1641 basic_dimensions.push_back(dimension(dimension::DECIBEL,prefix::NONE,dimension::NUMERATOR));
1642 break;
1643 }
1644 return basic_dimensions;
1645 }
1646
1647 void dimension::invert()
1648 {
1649 if (dimension_position == dimension::NUMERATOR)
1650 {
1651 dimension_position = dimension::DENOMINATOR;
1652 }
1653 else
1654 {
1655 dimension_position = dimension::NUMERATOR;
1656 }
1657 }
1658
1659 string to_string(const dimension& x)
1660 {
1661 ostringstream out;
1662 out << x.prefix << x.get_symbol();
1663 return out.str();
1664 }
1665
1666 string to_string(const vector<dimension>& x_dimensions,bool with_brackets)
1667 {
1668 ostringstream out;
1669 if (x_dimensions.size() > 0)
1670 {
1671 if (with_brackets)
1672 {
1673 out << "[";
1674 }
1675 vector<dimension::type> printed_dimensions = vector<dimension::type>();
1676 map<prefix,int> counted_prefixes = map<prefix,int>();
1677 bool first_print = true;
1678 for (const dimension& x_dimension : x_dimensions)
1679 {
1680 if (x_dimension.dimension_position == dimension::NUMERATOR)
1681 {
1682 bool printed = false;
1683 for (const dimension::type& print_dimension : printed_dimensions)
1684 {
1685 if (print_dimension == x_dimension.dimension_type)
1686 {
1687 printed = true;
1688 }
1689 }
1690 if (printed == true)
1691 {
1692 continue;
1693 }
1694 counted_prefixes = map<prefix,int>();
1695 for (const dimension& y_dimension : x_dimensions)
1696 {
1697 if (x_dimension.dimension_type == y_dimension.dimension_type)
1698 {
1699 counted_prefixes[y_dimension.prefix]++;
1700 }
1701 }
1702 for (const auto& x_prefix : counted_prefixes)
1703 {
1704 if (!first_print)
1705 {
1706 out << "*";
1707 }
1708 out << x_prefix.first << x_dimension.get_symbol();
1709 if (x_prefix.second > 1)
1710 {
1711 out << x_prefix.second;
1712 }
1713 first_print = false;
1714 }
1715 printed_dimensions.push_back(x_dimension.dimension_type);
1716 }
1717 }
1718 printed_dimensions.clear();
1719 bool first_negative_iteration = true;
1720 bool first_negative_prefix = true;
1721 for (const dimension& x_dimension : x_dimensions)
1722 {
1723 if (x_dimension.dimension_position == dimension::DENOMINATOR)
1724 {
1725 if (first_negative_iteration == true)
1726 {
1727 if (first_print)
1728 {
1729 out << "1";
1730 }
1731 out << "/";
1732 first_negative_iteration = false;
1733 }
1734 bool printed = false;
1735 for (const dimension::type& print_dimension : printed_dimensions)
1736 {
1737 if (print_dimension == x_dimension.dimension_type)
1738 {
1739 printed = true;
1740 }
1741 }
1742 if (printed == true)
1743 {
1744 continue;
1745 }
1746 counted_prefixes = map<prefix,int>();
1747 for (const dimension& y_dimension : x_dimensions)
1748 {
1749 if (x_dimension.dimension_type == y_dimension.dimension_type)
1750 {
1751 counted_prefixes[y_dimension.prefix]++;
1752 }
1753 }
1754 for (const auto& x_prefix : counted_prefixes)
1755 {
1756 if (first_negative_prefix == false)
1757 {
1758 out << "*";
1759 }
1760 out << x_prefix.first << x_dimension.get_symbol();
1761 if (x_prefix.second > 1)
1762 {
1763 out << x_prefix.second;
1764 }
1765 first_negative_prefix = false;
1766 }
1767 printed_dimensions.push_back(x_dimension.dimension_type);
1768 }
1769 }
1770 if (with_brackets)
1771 {
1772 out << "]";
1773 }
1774 }
1775 else
1776 {
1777 out << "[empty]";
1778 }
1779 return out.str();
1780 }
1781
1782 string to_latex(const vector<dimension>& x_dimensions,bool with_brackets)
1783 {
1784 ostringstream out;
1785 bool is_fraction = false;
1786 if (x_dimensions.size() > 0)
1787 {
1788 vector<dimension::type> printed_dimensions = vector<dimension::type>();
1789 map<prefix,int> counted_prefixes = map<prefix,int>();
1790 bool first_print = true;
1791 for (const dimension& x_dimension : x_dimensions)
1792 {
1793 if (x_dimension.dimension_position == dimension::NUMERATOR)
1794 {
1795 bool printed = false;
1796 for (const dimension::type& print_dimension : printed_dimensions)
1797 {
1798 if (print_dimension == x_dimension.dimension_type)
1799 {
1800 printed = true;
1801 }
1802 }
1803 if (printed == true)
1804 {
1805 continue;
1806 }
1807 counted_prefixes = map<prefix,int>();
1808 for (const dimension& y_dimension : x_dimensions)
1809 {
1810 if (x_dimension.dimension_type == y_dimension.dimension_type)
1811 {
1812 counted_prefixes[y_dimension.prefix]++;
1813 }
1814 }
1815 for (const auto& x_prefix : counted_prefixes)
1816 {
1817 if (!first_print)
1818 {
1819 out << "*";
1820 }
1821 out << x_prefix.first << x_dimension.get_symbol();
1822 if (x_prefix.second > 1)
1823 {
1824 out << "^" << x_prefix.second;
1825 }
1826 first_print = false;
1827 }
1828 printed_dimensions.push_back(x_dimension.dimension_type);
1829 }
1830 }
1831 printed_dimensions.clear();
1832 bool first_negative_iteration = true;
1833 bool first_negative_prefix = true;
1834 for (const dimension& x_dimension : x_dimensions)
1835 {
1836 if (x_dimension.dimension_position == dimension::DENOMINATOR)
1837 {
1838 is_fraction = true;
1839 if (first_negative_iteration == true)
1840 {
1841 if (first_print)
1842 {
1843 out << "1";
1844 }
1845 out << "}{";
1846 first_negative_iteration = false;
1847 }
1848 bool printed = false;
1849 for (const dimension::type& print_dimension : printed_dimensions)
1850 {
1851 if (print_dimension == x_dimension.dimension_type)
1852 {
1853 printed = true;
1854 }
1855 }
1856 if (printed == true)
1857 {
1858 continue;
1859 }
1860 counted_prefixes = map<prefix,int>();
1861 for (const dimension& y_dimension : x_dimensions)
1862 {
1863 if (x_dimension.dimension_type == y_dimension.dimension_type)
1864 {
1865 counted_prefixes[y_dimension.prefix]++;
1866 }
1867 }
1868 for (const auto& x_prefix : counted_prefixes)
1869 {
1870 if (first_negative_prefix == false)
1871 {
1872 out << "*";
1873 }
1874 out << x_prefix.first << x_dimension.get_symbol();
1875 if (x_prefix.second > 1)
1876 {
1877 out << "^" << x_prefix.second;
1878 }
1879 first_negative_prefix = false;
1880 }
1881 printed_dimensions.push_back(x_dimension.dimension_type);
1882 }
1883 }
1884 if (is_fraction)
1885 {
1886 out << "}";
1887 }
1888 if (with_brackets)
1889 {
1890 out << "]";
1891 }
1892 }
1893 else
1894 {
1895 out << "[empty]";
1896 }
1897 if (is_fraction)
1898 {
1899 if (with_brackets)
1900 {
1901 return "[\frac{" + out.str();
1902 }
1903 else
1904 {
1905 return "\frac{" + out.str();
1906 }
1907 }
1908 else
1909 {
1910 if (with_brackets)
1911 {
1912 return "[" + out.str();
1913 }
1914 else
1915 {
1916 return out.str();
1917 }
1918 }
1919 }
1920
1921 vector<dimension> create_dimensions(string init_dimensions)
1922 {
1923 boost::algorithm::erase_all(init_dimensions, " ");
1924 dimension::position new_sign = dimension::NUMERATOR;
1925 int new_scale = 1;
1926 int new_size = 1;
1927 int new_start = 0;
1928 icu::UnicodeString new_dimension_str;
1929 vector<dimension> dimensions = vector<dimension>();
1930 icu::UnicodeString x_unicode = icu::UnicodeString(init_dimensions.c_str());
1931 int total_chars = x_unicode.countChar32();
1932 for(unsigned int j = 0; j < total_chars; j++)
1933 {
1934 if(x_unicode[j] == UChar32(U'1') and x_unicode[j + 1] == UChar32(U'/'))
1935 {
1936 new_sign = dimension::DENOMINATOR;
1937 }
1938 if(is_dimension_char(x_unicode[j]) and (!is_dimension_char(x_unicode[j + 1]) or (j + 1) == total_chars))
1939 {
1940 new_dimension_str = x_unicode.tempSubString(new_start,new_size);
1941 if(u_isdigit(x_unicode[j + 1]))
1942 {
1943 new_scale = u_charDigitValue(x_unicode[j + 1]);
1944 }
1945 }
1946 if(x_unicode[j] == UChar32(U'*'))
1947 {
1948 new_size = 0;
1949 new_start = j + 1;
1950 }
1951 else if(x_unicode[j] == UChar32(U'/'))
1952 {
1953 new_sign = dimension::DENOMINATOR;
1954 new_size = 0;
1955 new_start = j + 1;
1956 }
1957 if(!new_dimension_str.countChar32() == 0)
1958 {
1959 dimension new_dimension;
1960 string new_dimension_str_stl2 = "";
1961 new_dimension_str.toUTF8String(new_dimension_str_stl2);
1962 if(new_dimension_str.countChar32() == 1)
1963 {
1964 if(new_dimension_str[0] == 0x03A9)
1965 {
1966 new_dimension = dimension(dimension::OHM,prefix::NONE,new_sign);
1967 }
1968 else if(new_dimension_str[0] == 0x00C5)
1969 {
1970 new_dimension = dimension(dimension::ANGSTROM,prefix::NONE,new_sign);
1971 }
1972 else if(new_dimension_str[0] == 0x03B8)
1973 {
1974 new_dimension = dimension(dimension::DEGREE,prefix::NONE,new_sign);
1975 }
1976 else
1977 {
1978 string new_dimension_str_stl = "";
1979 new_dimension_str.toUTF8String(new_dimension_str_stl);
1980 new_dimension = dimension(new_dimension_str_stl,new_sign);
1981 }
1982 }
1983 else
1984 {
1985 if(new_dimension_str[new_dimension_str.countChar32() - 1] == 0x03A9)
1986 {
1987 string new_prefix_str = "";
1988 new_dimension_str.tempSubString(0,new_dimension_str.countChar32() - 1).toUTF8String(new_prefix_str);
1989 prefix new_prefix(new_prefix_str);
1990 new_dimension = dimension(dimension::OHM,new_prefix,new_sign);
1991 }
1992 else if(new_dimension_str[new_dimension_str.countChar32() - 1] == 0x00C5)
1993 {
1994 string new_prefix_str = "";
1995 new_dimension_str.tempSubString(0,new_dimension_str.countChar32() - 1).toUTF8String(new_prefix_str);
1996 prefix new_prefix(new_prefix_str);
1997 new_dimension = dimension(dimension::ANGSTROM,new_prefix,new_sign);
1998 }
1999 else if(new_dimension_str[new_dimension_str.countChar32() - 1] == 0x03B8)
2000 {
2001 string new_prefix_str = "";
2002 new_dimension_str.tempSubString(0,new_dimension_str.countChar32() - 1).toUTF8String(new_prefix_str);
2003 prefix new_prefix(new_prefix_str);
2004 new_dimension = dimension(dimension::DEGREE,new_prefix,new_sign);
2005 }
2006 else if(new_dimension_str[new_dimension_str.countChar32() - 2] == 0x00B0 && new_dimension_str[new_dimension_str.countChar32() - 1] == 0x0043)
2007 {
2008 string new_prefix_str = "";
2009 new_dimension_str.tempSubString(0,new_dimension_str.countChar32() - 2).toUTF8String(new_prefix_str);
2010 prefix new_prefix(new_prefix_str);
2011 new_dimension = dimension(dimension::CELSIUS,new_prefix,new_sign);
2012 }
2013 else
2014 {
2015 string new_dimension_str_stl = "";
2016 new_dimension_str.toUTF8String(new_dimension_str_stl);
2017 new_dimension = dimension(new_dimension_str_stl,new_sign);
2018 }
2019 }
2020 for (int k = 0; k < new_scale; k++)
2021 {
2022 dimensions.push_back(new_dimension);
2023 }
2024 new_dimension_str.remove();
2025 new_scale = 1;
2026 new_size = 0;
2027 }
2028 new_size++;
2029 }
2030 return dimensions;
2031 }
2032
2038
2039 vector<dimension> create_base_dimensions(const vector<dimension>& x)
2040 {
2041 vector<dimension> new_x = vector<dimension>();
2042 for(unsigned int i = 0; i < x.size(); i++)
2043 {
2044 vector<dimension> x_subdimensions = x[i].get_base_dimensions();
2045 for (dimension& x_subdimension : x_subdimensions)
2046 {
2047 if (x[i].dimension_position == dimension::DENOMINATOR)
2048 {
2049 x_subdimension.invert();
2050 }
2051 new_x.push_back(x_subdimension);
2052 }
2053 }
2054 return new_x;
2055 }
2056
2057 vector<dimension> create_base_dimensions(const vector<dimension>& x,long double& value)
2058 {
2059 vector<dimension> new_x = vector<dimension>();
2060 for(unsigned int i = 0; i < x.size(); i++)
2061 {
2062 if (x[i].dimension_position == dimension::NUMERATOR)
2063 {
2064 value *= x[i].get_conversion_factor();
2065 value *= x[i].prefix_math();
2066 }
2067 else if (x[i].dimension_position == dimension::DENOMINATOR)
2068 {
2069 value /= x[i].get_conversion_factor();
2070 value /= x[i].prefix_math();
2071 }
2072 vector<dimension> x_subdimensions = x[i].get_base_dimensions();
2073 for (dimension& x_subdimension : x_subdimensions)
2074 {
2075 if (x[i].dimension_position == dimension::DENOMINATOR)
2076 {
2077 x_subdimension.invert();
2078 }
2079 new_x.push_back(x_subdimension);
2080 }
2081 }
2082 if (x.size() == 1 and x[0].dimension_type == dimension::CELSIUS and x[0].dimension_position == dimension::NUMERATOR)
2083 {
2084 value += 273.15l;
2085 }
2086 return new_x;
2087 }
2088
2089 vector<dimension> multiply_dimensions(const vector<dimension>& x,const vector<dimension>& y)
2090 {
2091 vector<dimension> new_dimensions = x;
2092 for(const dimension& y_dimension : y)
2093 {
2094 new_dimensions.push_back(y_dimension);
2095 }
2096 return new_dimensions;
2097 }
2098
2099 vector<dimension> multiply_dimensions(vector<dimension> x,const vector<dimension>& y,long double& value)
2100 {
2101 for(const dimension& y_dimension : y)
2102 {
2103 x.push_back(y_dimension);
2104 }
2105 return normalize_dimensions(x,value);
2106 }
2107
2108 vector<dimension> divide_dimensions(vector<dimension> x,const vector<dimension>& y,long double& value)
2109 {
2110 for(dimension y_dimension : y)
2111 {
2112 y_dimension.invert();
2113 x.push_back(y_dimension);
2114 }
2115 return normalize_dimensions(x,value);
2116 }
2117
2118 vector<dimension> square_dimensions(vector<dimension> x,int index,long double& value)
2119 {
2120 map<dimension::type,int> dimensions_count = map<dimension::type,int>();
2121 for (const dimension& x_dimension : x)
2122 {
2123 dimensions_count[x_dimension.dimension_type]++;
2124 }
2125 for (const auto& x_count : dimensions_count)
2126 {
2127 if ((x_count.second % index) != 0)
2128 {
2129 return vector<dimension>();
2130 }
2131 }
2132 vector<dimension> new_dimensions = vector<dimension>();
2133 if (dimensions_count.size() == 1) // If there's only one type of dimension, square it and conserve its type
2134 {
2135 for (int i = 0; i < dimensions_count[x[0].dimension_type]; i++)
2136 {
2137 if (x[i].dimension_position == dimension::NUMERATOR)
2138 {
2139 value *= x[i].get_conversion_factor();
2140 value *= x[i].prefix_math();
2141 }
2142 else if (x[i].dimension_position == dimension::DENOMINATOR)
2143 {
2144 value /= x[i].get_conversion_factor();
2145 value /= x[i].prefix_math();
2146 }
2147 }
2148 int total_dimensions = int(std::pow(dimensions_count[x[0].dimension_type], 1.0f / index));
2149 x[0].prefix.prefix_type = prefix::NONE;
2150 for (int j = 0; j < total_dimensions; j++)
2151 {
2152 new_dimensions.push_back(x[0]);
2153 }
2154 return new_dimensions;
2155 }
2156 else // If there's more than one type of dimension, creates the simple dimensions of them, and squares the total. If there are special names, they are changed by their simple dimensions
2157 {
2158 x = normalize_dimensions(x,value);
2159 vector<dimension::type> counted_dimensions = vector<dimension::type>();
2160 dimensions_count.clear();
2161 for (const dimension& x_dimension : x)
2162 {
2163 dimensions_count[x_dimension.dimension_type]++;
2164 }
2165 for (const dimension& x_dimension : x)
2166 {
2167 bool counted = false;
2168 for (const dimension::type& counted_dimension : counted_dimensions)
2169 {
2170 if (counted_dimension == x_dimension.dimension_type)
2171 {
2172 counted = true;
2173 }
2174 }
2175 if (counted == true)
2176 {
2177 continue;
2178 }
2179 int total_dimensions = int(std::pow(dimensions_count[x_dimension.dimension_type], 1.0f / index));
2180 for (int j = 0; j < total_dimensions; j++)
2181 {
2182 new_dimensions.push_back(x_dimension);
2183 }
2184 counted_dimensions.push_back(x_dimension.dimension_type);
2185 }
2186 }
2187 return new_dimensions;
2188 }
2189
2190 vector<dimension> power_dimensions(const vector<dimension>& x,int exponent)
2191 {
2192 vector<dimension> new_dimensions = vector<dimension>();
2193 for (const dimension& x_dimension: x)
2194 {
2195 for (unsigned int j = 1; j <= exponent; j++)
2196 {
2197 new_dimensions.push_back(x_dimension);
2198 }
2199 }
2200 return new_dimensions;
2201 }
2202
2203 vector<dimension> normalize_dimensions(const vector<dimension>& x)
2204 {
2205 vector<dimension> new_x = create_base_dimensions(x);
2206 if (new_x.size() == 1)
2207 {
2208 return x;
2209 }
2210 vector<unsigned int> skip_dimensions = vector<unsigned int>();
2211 for(unsigned int i = 0; i < new_x.size(); i++)
2212 {
2213 for(unsigned int j = i + 1; j < new_x.size(); j++)
2214 {
2215 if (skip_dimensions.size() > 0)
2216 {
2217 bool skip = false;
2218 for(unsigned int k = 0; k < skip_dimensions.size(); k++)
2219 {
2220 if (j == skip_dimensions[k])
2221 {
2222 skip = true;
2223 break;
2224 }
2225 }
2226 if (skip)
2227 {
2228 continue;
2229 }
2230 }
2231 if (new_x[i].dimension_type == new_x[j].dimension_type and new_x[i].dimension_position != new_x[j].dimension_position)
2232 {
2233 skip_dimensions.push_back(i);
2234 skip_dimensions.push_back(j);
2235 break;
2236 }
2237 }
2238 }
2239 vector<dimension> new_dimensions = vector<dimension>();
2240 for(unsigned int i = 0; i < new_x.size(); i++)
2241 {
2242 bool skip = false;
2243 for(unsigned int j = 0; j < skip_dimensions.size(); j++)
2244 {
2245 if (i == skip_dimensions[j])
2246 {
2247 skip = true;
2248 break;
2249 }
2250 }
2251 if (!skip)
2252 {
2253 new_dimensions.push_back(new_x[i]);
2254 }
2255 }
2256 return new_dimensions;
2257 }
2258
2259 vector<dimension> normalize_dimensions(const vector<dimension>& x,long double& value)
2260 {
2261 vector<dimension> new_x = create_base_dimensions(x,value);
2262 if (new_x.size() == 1)
2263 {
2264 return x;
2265 }
2266 vector<unsigned int> skip_dimensions = vector<unsigned int>();
2267 for(unsigned int i = 0; i < new_x.size(); i++)
2268 {
2269 for(unsigned int j = i + 1; j < new_x.size(); j++)
2270 {
2271 if (skip_dimensions.size() > 0)
2272 {
2273 bool skip = false;
2274 for(unsigned int k = 0; k < skip_dimensions.size(); k++)
2275 {
2276 if (j == skip_dimensions[k])
2277 {
2278 skip = true;
2279 break;
2280 }
2281 }
2282 if (skip)
2283 {
2284 continue;
2285 }
2286 }
2287 if (new_x[i].dimension_type == new_x[j].dimension_type and new_x[i].dimension_position != new_x[j].dimension_position)
2288 {
2289 if (new_x[i].dimension_position == dimension::NUMERATOR)
2290 {
2291 value *= float(new_x[i].get_conversion_factor());
2292 value *= float(new_x[i].prefix_math());
2293 }
2294 else if (new_x[i].dimension_position == dimension::DENOMINATOR)
2295 {
2296 value /= float(new_x[i].get_conversion_factor());
2297 value /= float(new_x[i].prefix_math());
2298 }
2299 if (new_x[j].dimension_position == dimension::NUMERATOR)
2300 {
2301 value *= float(new_x[j].get_conversion_factor());
2302 value *= float(new_x[j].prefix_math());
2303 }
2304 else if (new_x[j].dimension_position == dimension::DENOMINATOR)
2305 {
2306 value /= float(new_x[j].get_conversion_factor());
2307 value /= float(new_x[j].prefix_math());
2308 }
2309 skip_dimensions.push_back(i);
2310 skip_dimensions.push_back(j);
2311 break;
2312 }
2313 }
2314 }
2315 vector<dimension> new_dimensions = vector<dimension>();
2316 for(unsigned int i = 0; i < new_x.size(); i++)
2317 {
2318 bool skip = false;
2319 for(unsigned int j = 0; j < skip_dimensions.size(); j++)
2320 {
2321 if (i == skip_dimensions[j])
2322 {
2323 skip = true;
2324 break;
2325 }
2326 }
2327 if (!skip)
2328 {
2329 new_dimensions.push_back(new_x[i]);
2330 }
2331 }
2332 return new_dimensions;
2333 }
2334
2335 bool is_dimension_char(const UChar32& x)
2336 {
2337 return u_isalpha(x) || x == UChar32(U'Ω') || x == UChar32(U'Å') || x == UChar32(U'θ') || x == UChar32(U'°');
2338 }
2339
2340 bool common_dimension(const dimension& x,const dimension& y)
2341 {
2342 for (const dimension& x_dimension : x.get_base_dimensions())
2343 {
2344 for (const dimension& y_dimension : y.get_base_dimensions())
2345 {
2346 if (x_dimension.dimension_type == y_dimension.dimension_type and x_dimension.dimension_position == y_dimension.dimension_position)
2347 {
2348 return true;
2349 }
2350 }
2351 }
2352 return false;
2353 }
2354
2361
2362 bool equal_dimensions(const vector<dimension>& x,const vector<dimension>& y)
2363 {
2364 vector<dimension> x_base_dimensions = create_base_dimensions(x);
2365 vector<dimension> y_base_dimensions = create_base_dimensions(y);
2366 if (x_base_dimensions.size() == y_base_dimensions.size())
2367 {
2368 if (x_base_dimensions.size() == 0)
2369 {
2370 return true;
2371 }
2372 vector<unsigned int> skip = vector<unsigned int>();
2373 for (const dimension& x_dimension: x_base_dimensions)
2374 {
2375 bool is_equal = false;
2376 for (unsigned int j = 0; j < y_base_dimensions.size(); j++)
2377 {
2378 bool skip_j = false;
2379 if (skip.size() > 0)
2380 {
2381 for (unsigned int k = 0; k < skip.size(); k++)
2382 {
2383 if (j == skip[k])
2384 {
2385 skip_j = true;
2386 }
2387 }
2388 }
2389 if (skip_j)
2390 {
2391 continue;
2392 }
2393 if (x_dimension.dimension_type == y_base_dimensions[j].dimension_type and x_dimension.dimension_position == y_base_dimensions[j].dimension_position)
2394 {
2395 skip.push_back(j);
2396 is_equal = true;
2397 break;
2398 }
2399 }
2400 if (!is_equal)
2401 {
2402 return false;
2403 }
2404 }
2405 return true;
2406 }
2407 else
2408 {
2409 return false;
2410 }
2411 }
2412
2413 bool equal_dimensions_and_prefixes(const vector<dimension>& x,const vector<dimension>& y)
2414 {
2415 vector<unsigned int> skip = vector<unsigned int>();
2416 if (x.size() == y.size())
2417 {
2418 for (const dimension& x_dimension: x)
2419 {
2420 bool is_equal = false;
2421 for (unsigned int j = 0; j < y.size(); j++)
2422 {
2423 bool skip_j = false;
2424 if (skip.size() > 0)
2425 {
2426 for (unsigned int k = 0; k < skip.size(); k++)
2427 {
2428 if (j == skip[k])
2429 {
2430 skip_j = true;
2431 }
2432 }
2433 }
2434 if (skip_j)
2435 {
2436 continue;
2437 }
2438 if (x_dimension == y[j])
2439 {
2440 skip.push_back(j);
2441 is_equal = true;
2442 break;
2443 }
2444 }
2445 if (!is_equal)
2446 {
2447 return false;
2448 }
2449 }
2450 return true;
2451 }
2452 else
2453 {
2454 return false;
2455 }
2456 }
2457}
2458
2459bool operator ==(const scifir::dimension& x,const scifir::dimension& y)
2460{
2461 if (x.dimension_type == y.dimension_type and x.dimension_position == y.dimension_position and x.prefix == y.prefix)
2462 {
2463 return true;
2464 }
2465 else
2466 {
2467 return false;
2468 }
2469}
2470
2471bool operator !=(const scifir::dimension& x,const scifir::dimension& y)
2472{
2473 return !(x == y);
2474}
2475
2476ostream& operator <<(ostream& os, const scifir::dimension& x)
2477{
2478 return os << x.prefix.get_symbol() << x.get_symbol();
2479}
scifir::coordinates_1d
Definition coordinates_1d.hpp:18
scifir::dimension
Class that represents dimensions of the SI system of units. Each dimension sizes 6 bytes,...
Definition dimension.hpp:31
scifir::dimension::is_dimensionless
bool is_dimensionless() const
If the dimension_type is DEGREE, RADIAN or STERADIAN, it's considered dimensionless,...
Definition dimension.cpp:1384
scifir::dimension::position
position
Represents the position of the dimension, which can be at the numerator or at the denominator....
Definition dimension.hpp:38
scifir::dimension::DENOMINATOR
@ DENOMINATOR
The dimension is at the denominator.
Definition dimension.hpp:38
scifir::dimension::NUMERATOR
@ NUMERATOR
The dimension is at the numerator.
Definition dimension.hpp:38
scifir::dimension::operator=
dimension & operator=(const dimension &x)
Copy assignment. The dimension copies the dimension x.
scifir::dimension::get_fullplural
string get_fullplural() const
Returns the plural of the dimension with the name of the prefix first.
Definition dimension.cpp:603
scifir::dimension::is_composite_dimension
bool is_composite_dimension() const
If the dimension has more simple dimensions, it's a composite dimension.
Definition dimension.cpp:1000
scifir::dimension::get_name
string get_name() const
Returns the name of the dimension.
Definition dimension.cpp:358
scifir::dimension::prefix
scifir::prefix prefix
The prefix of the dimension. It's used along with the symbol of the dimension when printing it.
Definition dimension.hpp:74
scifir::dimension::dimension_position
dimension::position dimension_position
The position of the dimension, which can be the NUMERATOR, the DENOMINATOR or NO_POSITION....
Definition dimension.hpp:76
scifir::dimension::is_base_dimension
bool is_base_dimension() const
Returns true if the dimension is a base dimension, which includes all base dimensions of the SI syste...
Definition dimension.cpp:1012
scifir::dimension::symbol
char symbol[3]
The value of the position of the character of a custom dimension in the map of full_symbols.
Definition dimension.hpp:77
scifir::dimension::get_fullname
string get_fullname() const
Returns the name of the dimension with the name of the prefix first.
Definition dimension.cpp:478
scifir::dimension::is_SI_derived_dimension
bool is_SI_derived_dimension() const
If the dimension is not a SI base dimension, it's considered a SI derived dimension.
Definition dimension.cpp:1264
scifir::dimension::total_full_symbols
static int total_full_symbols
Definition dimension.hpp:169
scifir::dimension::dimension_type
dimension::type dimension_type
The type of the dimension.
Definition dimension.hpp:75
scifir::dimension::base_dimensions
static map< string, vector< dimension > > base_dimensions
Definition dimension.hpp:167
scifir::dimension::is_SI_base_dimension
bool is_SI_base_dimension() const
Returns true if the dimension is a SI base dimension. Following the SI system of units,...
Definition dimension.cpp:1144
scifir::dimension::is_simple_dimension
bool is_simple_dimension() const
If the dimension doesn't has more base dimensions, it's a simple dimension.
Definition dimension.cpp:880
scifir::dimension::type
type
Represents a dimension of the SI system of units. All the dimensions of the SI system of units are su...
Definition dimension.hpp:34
scifir::dimension::MOLARITY
@ MOLARITY
Molarity, plural molarities. The derived dimensions are mol / L. Dimension of concentration of a chem...
Definition dimension.hpp:35
scifir::dimension::NONE
@ NONE
No dimension. Default value for the default constructor.
Definition dimension.hpp:35
scifir::dimension::BECQUEREL
@ BECQUEREL
Becquerel, plural becquerels. The derived dimensions are 1 / s. Dimension of radioactivity....
Definition dimension.hpp:35
scifir::dimension::KATAL
@ KATAL
Katal, plural katals. The derived dimensions are mol / s. Dimension of catalytic activity....
Definition dimension.hpp:35
scifir::dimension::LITRE
@ LITRE
Litre, plural litres. The derived dimensions are dm3. Dimension of volume. Symbol L.
Definition dimension.hpp:35
scifir::dimension::LUMEN
@ LUMEN
Lumen, plural lumens. The derived dimensions are cd * sr Dimension of luminous flux....
Definition dimension.hpp:35
scifir::dimension::MEMO
@ MEMO
Memo, plural memos. Invented unit inside Scifir, it's not part of the SI system of units....
Definition dimension.hpp:35
scifir::dimension::STERADIAN
@ STERADIAN
Steradian, plural steradians. Dimension of solid angle. A solid angle is an angle in volume....
Definition dimension.hpp:35
scifir::dimension::TESLA
@ TESLA
Tesla, plural teslas. The derived dimensions are V * s / m2. Dimension of magnetic strength....
Definition dimension.hpp:35
scifir::dimension::INTERNATIONAL_UNIT
@ INTERNATIONAL_UNIT
International unit, plural international units. It measures the amount of effect or biological activi...
Definition dimension.hpp:35
scifir::dimension::BARN
@ BARN
Barn, plural barns. Dimension of area. The derived dimensions are 10^-28 m2. It's used inside nuclear...
Definition dimension.hpp:35
scifir::dimension::LIGHT_YEAR
@ LIGHT_YEAR
Light year, plural light years. Dimension of length. The derived dimensions are 9,...
Definition dimension.hpp:35
scifir::dimension::HENRY
@ HENRY
Henry, plural henries. The derived dimensions are V * s / A. Dimension of electric inductance....
Definition dimension.hpp:35
scifir::dimension::AMPERE
@ AMPERE
Ampere, plural amperes. The derived dimensions are C / s. Dimension of electric current....
Definition dimension.hpp:35
scifir::dimension::MOLE
@ MOLE
Mole, plural moles. SI dimension of quantity. Symbol mol.
Definition dimension.hpp:35
scifir::dimension::CUSTOM_FULL_SYMBOL
@ CUSTOM_FULL_SYMBOL
Custom dimension. It's identical to a CUSTOM dimension in his use, but its symbol is stored in the st...
Definition dimension.hpp:35
scifir::dimension::VOLT
@ VOLT
Volt, plural volts. The derived dimensions are J / C, W / A. Dimension of voltage....
Definition dimension.hpp:35
scifir::dimension::OHM
@ OHM
Ohm, plural ohms. The derived dimensions are V / A. Dimension of electric resistance....
Definition dimension.hpp:35
scifir::dimension::COULOMB
@ COULOMB
Coulomb, plural coulombs. SI dimension of charge. Special name. Symbol C.
Definition dimension.hpp:35
scifir::dimension::LUX
@ LUX
Lux, plural luxes. The derived dimensions are cd * sr / m2. Dimension of illuminance....
Definition dimension.hpp:35
scifir::dimension::GRAY
@ GRAY
Gray, plural grays. The derived dimensions are m2 / s2. Dimension of ionising radiation (absorbed dos...
Definition dimension.hpp:35
scifir::dimension::ANGSTROM
@ ANGSTROM
Ángstrom, plural angstroms. The derived dimensions are 10^-10 m. Dimension of length,...
Definition dimension.hpp:35
scifir::dimension::ELECTRON_VOLT
@ ELECTRON_VOLT
Electron volt, plural electron volts. The derived dimensions are 1.602176634 * 10^−19 J....
Definition dimension.hpp:35
scifir::dimension::GRAM
@ GRAM
Gram, plural grams. SI dimension of mass. Symbol g.
Definition dimension.hpp:35
scifir::dimension::SIEVERT
@ SIEVERT
Sievert, plural sieverts. The derived dimensions are J / kg. Dimension of ionising radiation (equival...
Definition dimension.hpp:35
scifir::dimension::DALTON
@ DALTON
Dalton, plural daltons. The derived dimensions are 1,66053886 * 10^-24. Dimension of mass....
Definition dimension.hpp:35
scifir::dimension::MILLIEQUIVALENT
@ MILLIEQUIVALENT
Milliequivalent, plural Milliequivalents. Amount of moles in a given chemical reaction needed to reac...
Definition dimension.hpp:35
scifir::dimension::CELSIUS
@ CELSIUS
Celsius, plural celsius. SI dimension of temperature, derived from kelvin. Symbol °C....
Definition dimension.hpp:35
scifir::dimension::DEGREE
@ DEGREE
Degree, plural degrees. Dimension of angle. Symbol θ.
Definition dimension.hpp:35
scifir::dimension::PASCAL
@ PASCAL
Pascal, plural pascals. The derived dimensions are kg / s2 * m. Dimension of pressure....
Definition dimension.hpp:35
scifir::dimension::PIXEL
@ PIXEL
Pixel, plural pixels. it represents the amount of pixels, it can be used as a replacemet of the metre...
Definition dimension.hpp:35
scifir::dimension::ATOMIC_MASS_UNIT
@ ATOMIC_MASS_UNIT
Atomic mass unit, plural atomic mass units. The derived dimensions are Da. Equivalent to the Dalton....
Definition dimension.hpp:35
scifir::dimension::ASTRONOMICAL_UNIT
@ ASTRONOMICAL_UNIT
Astronomical unit, plural astronomical units. Dimension of length. The derived dimensions are 149,...
Definition dimension.hpp:35
scifir::dimension::HERTZ
@ HERTZ
Hertz, plural hertz. The derived dimensions are 1 / s. Dimension of frequency. Special name....
Definition dimension.hpp:35
scifir::dimension::DAY
@ DAY
Day, plural days. The derived dimensions are 86,400 s. Dimension of time. Symbol day,...
Definition dimension.hpp:35
scifir::dimension::WATT
@ WATT
Watt, plural watts. The derived dimensions are kg * m2 / s3. Dimension of power. Special name....
Definition dimension.hpp:35
scifir::dimension::NEWTON
@ NEWTON
Newton, plural newtons. The derived dimensions are kg * m / s2. Dimension of force....
Definition dimension.hpp:35
scifir::dimension::HOUR
@ HOUR
Hour, plural hours. The derived dimensions are 3,600 s. Dimension of time. Symbol hour,...
Definition dimension.hpp:35
scifir::dimension::PARTICLES
@ PARTICLES
Total of particles, the total amount that the mole represents. It's not exactly a dimension,...
Definition dimension.hpp:35
scifir::dimension::MONEY
@ MONEY
Money, plural money. The money is not specified in a specific currency, you must use the ISO 4217 of ...
Definition dimension.hpp:35
scifir::dimension::BIT
@ BIT
Bit, plural bits. Dimension of amount of information, of each binary digit. Symbol bit.
Definition dimension.hpp:35
scifir::dimension::SECOND
@ SECOND
Second, plural seconds. SI dimension of time. Symbol s.
Definition dimension.hpp:35
scifir::dimension::MINUTE
@ MINUTE
Minute, plural minutes. The derived dimensions are 60 s. Dimension of time. Symbol min.
Definition dimension.hpp:35
scifir::dimension::CANDELA
@ CANDELA
Candela, plural candelas. SI dimension of luminous intensity. Symbol cd.
Definition dimension.hpp:35
scifir::dimension::RADIAN
@ RADIAN
Radian, plural radians. Dimension of angle. Special name. Symbol rad.
Definition dimension.hpp:35
scifir::dimension::BYTE
@ BYTE
Byte, plural bytes. Dimension of amount of information. Symbol B.
Definition dimension.hpp:35
scifir::dimension::SIEMENS
@ SIEMENS
Siemens, plural siemens. The derived dimensions are 1 / Ω. Dimension of electric conductance....
Definition dimension.hpp:35
scifir::dimension::JOULE
@ JOULE
Joule, plural joules. The derived dimensions are kg * m2 / s2. Dimension of energy....
Definition dimension.hpp:35
scifir::dimension::FARAD
@ FARAD
Farad, plural farads. The derived dimensions are A * s / V. Dimension of electric capacitance....
Definition dimension.hpp:35
scifir::dimension::WEBER
@ WEBER
Weber, plural webers. The derived dimensions are T * m2. Dimension of magnetic flux....
Definition dimension.hpp:35
scifir::dimension::KELVIN
@ KELVIN
Kelvin, plural kelvins. SI dimension of temperature. Symbol K.
Definition dimension.hpp:35
scifir::dimension::METRE
@ METRE
Meter, plural meters. SI dimension of length. Symbol m.
Definition dimension.hpp:35
scifir::dimension::PARSEC
@ PARSEC
Parsec, plural parsecs. Dimension of length. The derived dimensions are 3.2616 ly....
Definition dimension.hpp:35
scifir::dimension::CUSTOM
@ CUSTOM
Custom dimension. It means the dimension is a custom dimension, which can have any value and meaning,...
Definition dimension.hpp:35
scifir::dimension::get_symbol
string get_symbol() const
Returns the symbol of the dimension. In the case of a custom dimension, it returns the custom dimensi...
Definition dimension.cpp:608
scifir::dimension::get_plural
string get_plural() const
Returns the plural of the dimension.
Definition dimension.cpp:483
scifir::dimension::prefixes_options
static set< string > prefixes_options
Definition dimension.hpp:170
scifir::dimension::get_base_dimensions
vector< dimension > get_base_dimensions() const
Returns the base dimensions of the dimensions, which can be the same dimension or all the base dimens...
Definition dimension.cpp:1396
scifir::dimension::get_conversion_factor
long double get_conversion_factor() const
Returns the conversion factor of the dimension.
Definition dimension.cpp:743
scifir::dimension::full_symbols
static map< int, string > full_symbols
Definition dimension.hpp:168
scifir::dimension::is_derived_dimension
bool is_derived_dimension() const
If the dimension is not a base dimension, it's considered a derived dimension.
Definition dimension.cpp:1132
scifir::dimension::get_full_symbol
static string get_full_symbol(const char *x_symbol)
Returns the symbol of a custom_full_symbol dimension stored in the private static map dimension::full...
Definition dimension.hpp:145
scifir::dimension::dimension
dimension()
Default constructor. The dimension_type is NONE, the dimension_position is NO_POSITION,...
Definition dimension.cpp:27
scifir::dimension::prefix_math
long double prefix_math() const
Returns the math between the prefix and the dimension, which varies if the dimension is a B or anothe...
Definition dimension.cpp:863
scifir::dimension::invert
void invert()
Changes the position of the dimension to the reverse, from the NUMERATOR to the DENOMINATOR,...
Definition dimension.cpp:1647
scifir::dimension::create_full_symbol
static char * create_full_symbol(const string &full_symbol)
Creates a new dimension that's stored in the private static map dimension::full_symbols.
Definition dimension.hpp:87
scifir::prefix
Class that represents prefixes of the SI system of units. Each prefix sizes 1 byte....
Definition prefix.hpp:14
scifir::prefix::prefix
prefix()
Default constructor. The prefix_type is set to NONE.
Definition prefix.cpp:9
scifir::prefix::get_symbol
string get_symbol() const
Symbol of the prefix given the prefix_type. The symbol of micro is supported in his Unicode version.
Definition prefix.cpp:152
scifir::prefix::get_name
string get_name() const
Name of the prefix given the prefix_type.
Definition prefix.cpp:94
scifir::prefix::type
type
Represents a prefix of the SI system of units. All the prefixes of the SI system of units are support...
Definition prefix.hpp:16
scifir::prefix::NONE
@ NONE
There is no prefix. Then, the dimension is not increased or decreased by some factor.
Definition prefix.hpp:16
scifir::prefix::KILO
@ KILO
Prefix of a factor of 10^3.
Definition prefix.hpp:16
operator!=
bool operator!=(const scifir::dimension &x, const scifir::dimension &y)
Checks if the dimension type and the position of two dimensions are any of them different....
Definition dimension.cpp:2471
operator<<
ostream & operator<<(ostream &os, const scifir::dimension &x)
Adds the string representation of a dimension to an output stream.
Definition dimension.cpp:2476
operator==
bool operator==(const scifir::dimension &x, const scifir::dimension &y)
Checks if the dimension type, the position and the prefix of two dimensions are the same.
Definition dimension.cpp:2459
scifir
The namespace scifir contains all scifir-units, excepting the string literals, which are outside.
Definition address.cpp:6
scifir::equal_dimensions
bool equal_dimensions(const string &init_dimensions_x, const string &init_dimensions_y)
Checks if two initialization strings of dimensions initialize the same basic dimensions.
Definition dimension.cpp:2355
scifir::divide_dimensions
vector< dimension > divide_dimensions(vector< dimension > x, const vector< dimension > &y, long double &value)
Divides the first vector of dimensions with the other. The result is normalized after,...
Definition dimension.cpp:2108
scifir::astronomical_body::NONE
@ NONE
No predefined astronomical body selected.
scifir::equal_dimensions_and_prefixes
bool equal_dimensions_and_prefixes(const vector< dimension > &x, const vector< dimension > &y)
Checks if the base dimensions of two vectors of dimensions are equal, and if they have also the same ...
Definition dimension.cpp:2413
scifir::common_dimension
bool common_dimension(const dimension &x, const dimension &y)
Checks if there's an equal basic dimension between the basic dimensions of those two dimensions.
Definition dimension.cpp:2340
scifir::normalize_dimensions
vector< dimension > normalize_dimensions(const vector< dimension > &x)
Normalizes the dimensions, which means that repited dimensions at the numerator and at the denominato...
Definition dimension.cpp:2203
scifir::to_string
string to_string(const aid &x)
Creates a string representation of aid, it's for aid equivalent to the display() function of aid.
Definition aid.cpp:582
scifir::create_base_dimensions
vector< dimension > create_base_dimensions(const string &init_dimensions)
Creates the base dimensions from an initialization string of dimensions.
Definition dimension.cpp:2033
scifir::is_dimension_char
bool is_dimension_char(const UChar32 &x)
Definition dimension.cpp:2335
scifir::AVOGADRO_CONSTANT
const long double AVOGADRO_CONSTANT
Definition constants.hpp:15
scifir::to_latex
string to_latex(const vector< dimension > &x_dimensions, bool with_brackets)
Definition dimension.cpp:1782
scifir::multiply_dimensions
vector< dimension > multiply_dimensions(const vector< dimension > &x, const vector< dimension > &y)
Multiplies two vectors of dimensions. The result is normalized after, which means that equal dimensio...
Definition dimension.cpp:2089
scifir::square_dimensions
vector< dimension > square_dimensions(vector< dimension > x, int index, long double &value)
Squares a vector of dimensions by an index. The value is updated too related to the prefix math and t...
Definition dimension.cpp:2118
scifir::create_dimensions
vector< dimension > create_dimensions(string init_dimensions)
Creates the dimensions from an initialization string of dimensions.
Definition dimension.cpp:1921
scifir::power_dimensions
vector< dimension > power_dimensions(const vector< dimension > &x, int exponent)
Powers the dimensions by an exponent.
Definition dimension.cpp:2190
Generated by doxygen 1.9.8