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
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
scalar_unit.cpp
Go to the documentation of this file.
1#include "./scalar_unit.hpp"
2
3#include "./conversion.hpp"
4#include "./base_units.hpp"
5#include "./prefix.hpp"
6#include "../util/types.hpp"
7
8#include "boost/algorithm/string/erase.hpp"
9#include "boost/algorithm/string.hpp"
10
11#include <algorithm>
12#include <cctype>
13#include <cmath>
14#include <iostream>
15#include <map>
16#include <sstream>
17#include <string>
18
19using namespace std;
20
21namespace scifir
22{
23 scalar_unit::scalar_unit() : dimensions(),value(0.0f)
24 {}
25
26 scalar_unit::scalar_unit(const scalar_unit& x) : dimensions(x.get_dimensions()),value(x.get_value())
27 {}
28
29 scalar_unit::scalar_unit(scalar_unit&& x) : dimensions(std::move(x.get_dimensions())),value(std::move(x.get_value()))
30 {}
31
34
37
40
43
46
49
50 scalar_unit::scalar_unit(long double new_value, const string& init_dimensions) : dimensions(create_dimensions(init_dimensions)),value(float(new_value))
51 {}
52
55
58
61
64
67
72
73 scalar_unit& scalar_unit::operator =(const scalar_unit& x)
74 {
75 if (has_dimensions(x))
76 {
77 dimensions = x.get_dimensions();
78 value = x.get_value();
79 }
80 else
81 {
82 cerr << "Cannot initialize to different dimensions" << endl;
83 }
84 return *this;
85 }
86
87 scalar_unit& scalar_unit::operator =(scalar_unit&& x)
88 {
89 if (has_dimensions(x))
90 {
91 dimensions = std::move(x.get_dimensions());
92 value = std::move(x.get_value());
93 }
94 else
95 {
96 cerr << "Cannot initialize to different dimensions" << endl;
97 }
98 return *this;
99 }
100
106
107 scalar_unit::operator float() const
108 {
109 return value;
110 }
111
112 bool scalar_unit::operator ==(scalar_unit x) const
113 {
114 x.change_dimensions(*this);
115 if(get_value() == x.get_value() and has_dimensions(x))
116 {
117 return true;
118 }
119 else
120 {
121 return false;
122 }
123 }
124
125 scalar_unit scalar_unit::operator +(scalar_unit x) const
126 {
127 if(has_dimensions(x))
128 {
129 x.change_dimensions(*this);
130 scalar_unit a = *this;
131 a += x.get_value();
132 return a;
133 }
134 else
135 {
136 cerr << "Cannot sum different dimensions" << endl;
137 return scalar_unit();
138 }
139 }
140
141 scalar_unit scalar_unit::operator -(scalar_unit x) const
142 {
143 if(has_dimensions(x))
144 {
145 x.change_dimensions(*this);
146 scalar_unit a = *this;
147 a -= x.get_value();
148 return a;
149 }
150 else
151 {
152 cerr << "Cannot substract different dimensions" << endl;
153 return scalar_unit();
154 }
155 }
156
164
172
173 scalar_unit scalar_unit::operator ^(const scalar_unit& x) const
174 {
175 if(x.has_empty_dimensions())
176 {
177 return scalar_unit(std::pow(value,x.get_value()),power_dimensions(get_dimensions(),int(x.get_value())));
178 }
179 else
180 {
181 cerr << "Exponent with dimensions doesn't exist" << endl;
182 return scalar_unit();
183 }
184 }
185
186 void scalar_unit::operator +=(scalar_unit x)
187 {
188 if(!has_dimensions(x))
189 {
190 cerr << "Cannot sum different dimensions" << endl;
191 return;
192 }
193 x.change_dimensions(*this);
194 value += x.get_value();
195 }
196
197 void scalar_unit::operator -=(scalar_unit x)
198 {
199 if(!has_dimensions(x))
200 {
201 cerr << "Cannot substract different dimensions" << endl;
202 return;
203 }
204 x.change_dimensions(*this);
205 value -= x.get_value();
206 }
207
208 scalar_unit& scalar_unit::operator ++()
209 {
210 value++;
211 return *this;
212 }
213
214 scalar_unit& scalar_unit::operator ++(int)
215 {
216 scalar_unit& tmp(*this);
217 operator ++();
218 return tmp;
219 }
220
221 scalar_unit& scalar_unit::operator --()
222 {
223 value--;
224 return *this;
225 }
226
227 scalar_unit& scalar_unit::operator --(int)
228 {
229 scalar_unit& tmp(*this);
230 operator --();
231 return tmp;
232 }
233
234 void scalar_unit::change_dimensions(const string& init_dimensions)
235 {
236 vector<dimension> new_dimensions = create_dimensions(init_dimensions);
237 if(has_dimensions(new_dimensions))
238 {
239 if (equal_dimensions_and_prefixes(dimensions,new_dimensions))
240 {
241 return;
242 }
243 for(const dimension& actual_dimension : dimensions)
244 {
245 remove_dimension(actual_dimension);
246 if(actual_dimension.is_composite_dimension())
247 {
248 vector<dimension> base_dimensions = actual_dimension.get_base_dimensions();
249 for(const dimension& base_dimension : base_dimensions)
250 {
251 remove_dimension(base_dimension);
252 }
253 }
254 }
255 if (dimensions.size() == 1)
256 {
257 if (dimensions[0].dimension_type == dimension::CELSIUS and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::KELVIN and new_dimensions[0].dimension_position == dimension::NUMERATOR)
258 {
259 value += 273.15f;
260 }
261 else if (dimensions[0].dimension_type == dimension::KELVIN and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::CELSIUS and new_dimensions[0].dimension_position == dimension::NUMERATOR)
262 {
263 value -= 273.15f;
264 }
265 }
266 dimensions.clear();
267 for(const dimension& new_dimension : new_dimensions)
268 {
269 add_dimension(new_dimension);
270 if(new_dimension.is_composite_dimension())
271 {
272 vector<dimension> new_base_dimensions = new_dimension.get_base_dimensions();
273 for(const dimension& new_base_dimension : new_base_dimensions)
274 {
275 add_dimension(new_base_dimension);
276 }
277 }
278 }
279 dimensions = new_dimensions;
280 }
281 else
282 {
283 cerr << "Cannot change to different base dimensions" << endl;
284 }
285 }
286
287 void scalar_unit::change_dimensions(const scalar_unit& x)
288 {
289 if(has_dimensions(x.get_dimensions()))
290 {
291 if (equal_dimensions_and_prefixes(dimensions,x.get_dimensions()))
292 {
293 return;
294 }
295 for(const dimension& actual_dimension : dimensions)
296 {
297 remove_dimension(actual_dimension);
298 if(actual_dimension.is_composite_dimension())
299 {
300 vector<dimension> base_dimensions = actual_dimension.get_base_dimensions();
301 for(const dimension& base_dimension : base_dimensions)
302 {
303 remove_dimension(base_dimension);
304 }
305 }
306 }
307 if (dimensions.size() == 1 and x.get_dimensions().size() == 1)
308 {
309 if (dimensions[0].dimension_type == dimension::CELSIUS and dimensions[0].dimension_position == dimension::NUMERATOR and x.get_dimensions()[0].dimension_type == dimension::KELVIN and x.get_dimensions()[0].dimension_position == dimension::NUMERATOR)
310 {
311 value += 273.15f;
312 }
313 else if (dimensions[0].dimension_type == dimension::KELVIN and dimensions[0].dimension_position == dimension::NUMERATOR and x.get_dimensions()[0].dimension_type == dimension::CELSIUS and x.get_dimensions()[0].dimension_position == dimension::NUMERATOR)
314 {
315 value -= 273.15f;
316 }
317 }
318 dimensions.clear();
319 for(const dimension& new_dimension : x.get_dimensions())
320 {
321 add_dimension(new_dimension);
322 if(new_dimension.is_composite_dimension())
323 {
324 vector<dimension> new_base_dimensions = new_dimension.get_base_dimensions();
325 for(const dimension& new_base_dimension : new_base_dimensions)
326 {
327 add_dimension(new_base_dimension);
328 }
329 }
330 }
331 dimensions = x.get_dimensions();
332 }
333 else
334 {
335 cerr << "Cannot change to different base dimensions" << endl;
336 }
337 }
338
344
349
350 bool scalar_unit::has_dimensions(const scalar_unit& x) const
351 {
352 return equal_dimensions(dimensions,x.get_dimensions());
353 }
354
355 bool scalar_unit::has_empty_dimensions() const
356 {
357 if(dimensions.size() == 0)
358 {
359 return true;
360 }
361 else
362 {
363 return false;
364 }
365 }
366
367 bool scalar_unit::is_dimensionless() const
368 {
369 if (has_empty_dimensions())
370 {
371 return true;
372 }
373 else
374 {
375 for (const dimension& x : dimensions)
376 {
377 if (!x.is_dimensionless())
378 {
379 return false;
380 }
381 }
382 return true;
383 }
384 }
385
386 bool scalar_unit::has_simple_dimensions() const
387 {
388 if (dimensions.size() == 1)
389 {
390 return dimensions[0].is_simple_dimension();
391 }
392 else
393 {
394 return false;
395 }
396 }
397
398 bool scalar_unit::has_single_dimensions() const
399 {
400 return (dimensions.size() == 1);
401 }
402
403 bool scalar_unit::has_composite_dimensions() const
404 {
405 if (dimensions.size() == 0)
406 {
407 return false;
408 }
409 else if (dimensions.size() == 1)
410 {
411 return dimensions[0].is_composite_dimension();
412 }
413 else
414 {
415 return true;
416 }
417 }
418
419 string scalar_unit::display_dimensions() const
420 {
421 return to_string(dimensions);
422 }
423
424 /*string scalar_unit::get_dimensions_match() const
425 {
426 return "";
427 }*/
428
429 dimension::type scalar_unit::get_single_dimension_type() const
430 {
431 if (dimensions.size() == 1)
432 {
433 return dimensions[0].dimension_type;
434 }
435 else
436 {
437 return dimension::NONE;
438 }
439 }
440
445
446 string scalar_unit::display(int number_of_decimals,bool with_brackets,bool use_close_prefix) const
447 {
448 ostringstream output;
449 if (dimensions.size() == 1 and use_close_prefix == true)
450 {
451 prefix display_prefix;
452 if (get_value() != 0)
453 {
454 int value_scale = int(log10(get_value()));
455 display_prefix = closest_prefix(dimensions[0].prefix,value_scale);
456 }
457 else
458 {
459 display_prefix = dimensions[0].prefix;
460 }
461 long double x_value = get_value();
462 x_value *= dimensions[0].prefix_math();
463 x_value /= dimensions[0].prefix_math(display_prefix);
464 vector<dimension> x_dimensions = dimensions;
465 x_dimensions[0].prefix = display_prefix;
466 output << display_float(float(x_value),number_of_decimals) << " " << to_string(x_dimensions,with_brackets);
467 }
468 else
469 {
470 output << display_float(get_value(),number_of_decimals) << " " << to_string(dimensions,with_brackets);
471 }
472 return output.str();
473 }
474
475 string scalar_unit::base_display(int number_of_decimals,bool with_brackets,bool use_close_prefix) const
476 {
477 ostringstream output;
478 long double x_value = get_value();
479 vector<dimension> base_dimensions = create_base_dimensions(dimensions,x_value);
480 if (base_dimensions.size() == 1 and use_close_prefix == true)
481 {
482 int value_scale = int(log10(get_value()));
483 prefix display_prefix = closest_prefix(base_dimensions[0].prefix,value_scale);
484 x_value *= base_dimensions[0].prefix_math();
485 x_value /= base_dimensions[0].prefix_math(display_prefix);
486 vector<dimension> x_dimensions = base_dimensions;
487 x_dimensions[0].prefix = display_prefix;
488 output << display_float(float(x_value),number_of_decimals) << " " << to_string(base_dimensions,with_brackets);
489 }
490 else
491 {
492 output << display_float(float(x_value),number_of_decimals) << " " << to_string(base_dimensions,with_brackets);
493 }
494 return output.str();
495 }
496
497 string scalar_unit::custom_display(const string& init_dimensions,int number_of_decimals,bool with_brackets) const
498 {
499 ostringstream output;
500 long double new_value = get_value();
501 if (init_dimensions != "sci")
502 {
503 for(const dimension& x_dimension : dimensions)
504 {
505 if (x_dimension.dimension_position == dimension::NUMERATOR)
506 {
507 new_value *= x_dimension.get_conversion_factor();
508 new_value *= x_dimension.prefix_math();
509 }
510 else if (x_dimension.dimension_position == dimension::DENOMINATOR)
511 {
512 new_value /= x_dimension.get_conversion_factor();
513 new_value /= x_dimension.prefix_math();
514 }
515 }
516 vector<dimension> base_dimensions = create_base_dimensions(dimensions);
517 for(const dimension& x_dimension : base_dimensions)
518 {
519 if (x_dimension.dimension_position == dimension::NUMERATOR)
520 {
521 new_value *= x_dimension.prefix_math();
522 }
523 else if (x_dimension.dimension_position == dimension::DENOMINATOR)
524 {
525 new_value /= x_dimension.prefix_math();
526 }
527 }
528 vector<dimension> new_dimensions = create_dimensions(init_dimensions);
529 if (dimensions.size() == 1 and new_dimensions.size() == 1)
530 {
531 if (dimensions[0].dimension_type == dimension::CELSIUS and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::KELVIN and new_dimensions[0].dimension_position == dimension::NUMERATOR)
532 {
533 new_value += 273.15l;
534 }
535 else if (dimensions[0].dimension_type == dimension::KELVIN and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::CELSIUS and new_dimensions[0].dimension_position == dimension::NUMERATOR)
536 {
537 new_value -= 273.15l;
538 }
539 }
540 for(const dimension& x_new_dimension : new_dimensions)
541 {
542 if (x_new_dimension.dimension_position == dimension::NUMERATOR)
543 {
544 new_value /= x_new_dimension.get_conversion_factor();
545 new_value /= x_new_dimension.prefix_math();
546 }
547 else if (x_new_dimension.dimension_position == dimension::DENOMINATOR)
548 {
549 new_value *= x_new_dimension.get_conversion_factor();
550 new_value *= x_new_dimension.prefix_math();
551 }
552 }
553 output << display_float(float(new_value),number_of_decimals) << " ";
554 if (with_brackets)
555 {
556 output << "[";
557 }
558 output << init_dimensions;
559 if (with_brackets)
560 {
561 output << "]";
562 }
563 }
564 else
565 {
566 for (const dimension& x_dimension : dimensions)
567 {
568 new_value *= x_dimension.prefix_math();
569 }
570 vector<dimension> new_dimensions = dimensions;
571 for (dimension& x_new_dimension : new_dimensions)
572 {
573 x_new_dimension.prefix.prefix_type = prefix::NONE;
574 }
575 int value_scale = int(log10(get_value()));
576 output << display_float(float(new_value / std::pow(10,value_scale)),number_of_decimals) << "e" << value_scale << " " << to_string(new_dimensions,with_brackets);
577 }
578 return output.str();
579 }
580
581 string scalar_unit::to_latex(const string& init_dimensions,int number_of_decimals,bool with_brackets) const
582 {
583 ostringstream output;
584 long double new_value = get_value();
585 if (init_dimensions != "sci")
586 {
587 vector<dimension> new_dimensions;
588 if (init_dimensions != "")
589 {
590 for(const dimension& x_dimension : dimensions)
591 {
592 if (x_dimension.dimension_position == dimension::NUMERATOR)
593 {
594 new_value *= x_dimension.get_conversion_factor();
595 new_value *= x_dimension.prefix_math();
596 }
597 else if (x_dimension.dimension_position == dimension::DENOMINATOR)
598 {
599 new_value /= x_dimension.get_conversion_factor();
600 new_value /= x_dimension.prefix_math();
601 }
602 }
603 vector<dimension> base_dimensions = create_base_dimensions(dimensions);
604 for(const dimension& x_dimension : base_dimensions)
605 {
606 if (x_dimension.dimension_position == dimension::NUMERATOR)
607 {
608 new_value *= x_dimension.prefix_math();
609 }
610 else if (x_dimension.dimension_position == dimension::DENOMINATOR)
611 {
612 new_value /= x_dimension.prefix_math();
613 }
614 }
615 new_dimensions = create_dimensions(init_dimensions);
616 if (dimensions.size() == 1 and new_dimensions.size() == 1)
617 {
618 if (dimensions[0].dimension_type == dimension::CELSIUS and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::KELVIN and new_dimensions[0].dimension_position == dimension::NUMERATOR)
619 {
620 new_value += 273.15l;
621 }
622 else if (dimensions[0].dimension_type == dimension::KELVIN and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::CELSIUS and new_dimensions[0].dimension_position == dimension::NUMERATOR)
623 {
624 new_value -= 273.15l;
625 }
626 }
627 for(const dimension& x_new_dimension : new_dimensions)
628 {
629 if (x_new_dimension.dimension_position == dimension::NUMERATOR)
630 {
631 new_value /= x_new_dimension.get_conversion_factor();
632 new_value /= x_new_dimension.prefix_math();
633 }
634 else if (x_new_dimension.dimension_position == dimension::DENOMINATOR)
635 {
636 new_value *= x_new_dimension.get_conversion_factor();
637 new_value *= x_new_dimension.prefix_math();
638 }
639 }
640 }
641 else
642 {
643 new_dimensions = dimensions;
644 }
645 output << display_float(float(new_value),number_of_decimals) << " " << scifir::to_latex(new_dimensions,with_brackets);
646 }
647 else
648 {
649 for (const dimension& x_dimension : dimensions)
650 {
651 new_value *= x_dimension.prefix_math();
652 }
653 vector<dimension> new_dimensions = dimensions;
654 for (dimension& x_new_dimension : new_dimensions)
655 {
656 x_new_dimension.prefix.prefix_type = prefix::NONE;
657 }
658 int value_scale = int(log10(get_value()));
659 output << display_float(float(new_value / std::pow(10,value_scale)),number_of_decimals) << "e" << value_scale << " " << scifir::to_latex(new_dimensions,with_brackets);
660 }
661 return output.str();
662 }
663
664 void scalar_unit::add_dimension(const dimension& new_dimension)
665 {
666 if (new_dimension.dimension_position == dimension::NUMERATOR)
667 {
668 value /= float(new_dimension.get_conversion_factor());
669 value /= float(new_dimension.prefix_math());
670 }
671 else if (new_dimension.dimension_position == dimension::DENOMINATOR)
672 {
673 value *= float(new_dimension.get_conversion_factor());
674 value *= float(new_dimension.prefix_math());
675 }
676 }
677
678 void scalar_unit::remove_dimension(const dimension& old_dimension)
679 {
680 if (old_dimension.dimension_position == dimension::NUMERATOR)
681 {
682 value *= float(old_dimension.get_conversion_factor());
683 value *= float(old_dimension.prefix_math());
684 }
685 else if (old_dimension.dimension_position == dimension::DENOMINATOR)
686 {
687 value /= float(old_dimension.get_conversion_factor());
688 value /= float(old_dimension.prefix_math());
689 }
690 }
691
692 void scalar_unit::initialize_from_string(string init_scalar,const vector<dimension>& real_dimensions)
693 {
694 if(!isdigit(init_scalar[0]))
695 {
696 return;
697 }
698 else
699 {
700 int i = 0;
701 while(isdigit(init_scalar[i]) || init_scalar[i] == '.' || init_scalar[i] == ' ' || init_scalar[i] == '*' || init_scalar[i] == '^' || init_scalar[i] == 'e' || init_scalar[i] == 'E')
702 {
703 if (init_scalar[i] == ' ')
704 {
705 break;
706 }
707 i++;
708 }
709 string string_value = init_scalar.substr(0, i);
710 boost::algorithm::erase_all(string_value, " ");
711 size_t search_e = string_value.find("E");
712 if (search_e != string::npos)
713 {
714 string_value.replace(search_e,1,"e");
715 }
716 size_t search_10 = string_value.find("*10^");
717 if (search_10 != string::npos)
718 {
719 string_value.replace(search_10,4,"e");
720 }
721 const vector<dimension> new_dimensions = create_dimensions(init_scalar.substr(i));
722 if (real_dimensions.size() == 0 or equal_dimensions(new_dimensions,real_dimensions))
723 {
724 stringstream ss(string_value);
725 ss >> value;
726 dimensions = new_dimensions;
727 }
728 }
729 }
730
731 void scalar_unit::check_dimensions(const vector<dimension>& real_dimensions)
732 {
733 if (!has_dimensions(real_dimensions))
734 {
735 value = 0;
736 dimensions.clear();
737 }
738 }
739
740 string to_string(const scalar_unit& x)
741 {
742 return x.display(2);
743 }
744
745 bool is_scalar_unit(const string& init_scalar)
746 {
747 bool dot_present = false;
748 bool e_present = false;
749 unsigned int current_pos = 0;
750 int e_present_pos = 0;
751 for (unsigned int i = 0; i < init_scalar.length(); i++)
752 {
753 if (init_scalar[i] == ' ')
754 {
755 if (e_present and ((unsigned int)(e_present_pos + 1) == i))
756 {
757 return false;
758 }
759 current_pos = i;
760 break;
761 }
762 if (e_present == false)
763 {
764 if (init_scalar[i] == '.')
765 {
766 if (dot_present)
767 {
768 return false;
769 }
770 else
771 {
772 dot_present = true;
773 }
774 }
775 else if (init_scalar[i] == 'e' or init_scalar[i] == 'E')
776 {
777 e_present = true;
778 e_present_pos = i;
779 continue;
780 }
781 else if (init_scalar[i] == '*')
782 {
783 if (!(init_scalar.substr(i + 1,3) == "10^"))
784 {
785 return false;
786 }
787 else
788 {
789 e_present = true;
790 i += 3;
791 e_present_pos = i;
792 continue;
793 }
794 }
795 else if (!isdigit(init_scalar[i]))
796 {
797 return false;
798 }
799 else if (i == (init_scalar.length() - 1))
800 {
801 return false;
802 }
803 }
804 else
805 {
806 if (!isdigit(init_scalar[i]))
807 {
808 return false;
809 }
810 }
811 }
812 if (current_pos == (init_scalar.length() - 1))
813 {
814 return false;
815 }
816 if (current_pos == 0)
817 {
818 return false;
819 }
820 bool brackets_present = false;
821 if (init_scalar.at(current_pos + 1) == '[')
822 {
823 if (init_scalar.at(init_scalar.size() - 1) != ']')
824 {
825 return false;
826 }
827 current_pos++;
828 brackets_present = true;
829 }
830 vector<string> values;
831 boost::split(values,init_scalar.substr(current_pos + 1,init_scalar.size() - 1),boost::is_any_of("/"));
832 if (brackets_present)
833 {
834 values[values.size() - 1] = values[values.size() - 1].substr(0,values[values.size() - 1].size() - 1);
835 }
836 if (values.size() == 1)
837 {
838 vector<string> subvalues;
839 boost::split(subvalues,values[0],boost::is_any_of("*"));
840 for (string& x_subvalue : subvalues)
841 {
842 boost::trim(x_subvalue);
843 bool number_present = false;
844 for (unsigned int i = 0; i < x_subvalue.length(); i++)
845 {
846 if (number_present == false)
847 {
848 if (isdigit(x_subvalue[i]))
849 {
850 number_present = true;
851 continue;
852 }
853 else if (!isalpha(x_subvalue[i]))
854 {
855 return false;
856 }
857 }
858 else
859 {
860 if (!isdigit(x_subvalue[i]))
861 {
862 return false;
863 }
864 }
865 }
866 }
867 return true;
868 }
869 else if (values.size() == 2)
870 {
871 if (values[0] != "1")
872 {
873 vector<string> subvalues;
874 boost::split(subvalues,values[0],boost::is_any_of("*"));
875 for (string& x_subvalue : subvalues)
876 {
877 boost::trim(x_subvalue);
878 bool number_present = false;
879 for (unsigned int i = 0; i < x_subvalue.length(); i++)
880 {
881 if (number_present == false)
882 {
883 if (isdigit(x_subvalue[i]))
884 {
885 number_present = true;
886 continue;
887 }
888 else if (!isalpha(x_subvalue[i]))
889 {
890 return false;
891 }
892 }
893 else
894 {
895 if (!isdigit(x_subvalue[i]))
896 {
897 return false;
898 }
899 }
900 }
901 }
902 }
903 vector<string> subvalues_denominator;
904 boost::split(subvalues_denominator,values[1],boost::is_any_of("*"));
905 for (string& x_subvalue : subvalues_denominator)
906 {
907 boost::trim(x_subvalue);
908 bool number_present = false;
909 for (unsigned int i = 0; i < x_subvalue.length(); i++)
910 {
911 if (number_present == false)
912 {
913 if (isdigit(x_subvalue[i]))
914 {
915 number_present = true;
916 continue;
917 }
918 else if (!isalpha(x_subvalue[i]))
919 {
920 return false;
921 }
922 }
923 else
924 {
925 if (!isdigit(x_subvalue[i]))
926 {
927 return false;
928 }
929 }
930 }
931 }
932 return true;
933 }
934 return false;
935 }
936
937 float abs(const scalar_unit& x)
938 {
939 return std::abs(x.get_value());
940 }
941
942 scalar_unit pow(const scalar_unit& x,int exponent)
943 {
944 return x ^ exponent;
945 }
946
954
955 scalar_unit sqrt_nth(const scalar_unit& x, int index)
956 {
957 long double new_value = x.get_value();
958 vector<dimension> new_dimensions = square_dimensions(x.get_dimensions(), index, new_value);
959 new_value = std::pow(new_value, 1.0f / index);
960 return scalar_unit(new_value, new_dimensions);
961 }
962}
963
964bool operator !=(const scifir::scalar_unit& x, scifir::scalar_unit y)
965{
966 return !(x == y);
967}
968
969bool operator <(const scifir::scalar_unit& x, const scifir::scalar_unit& y)
970{
971 if(!x.has_dimensions(y))
972 {
973 return false;
974 }
975 scifir::scalar_unit z = x;
976 z.change_dimensions(y);
977 if(z.get_value() < y.get_value())
978 {
979 return true;
980 }
981 else
982 {
983 return false;
984 }
985}
986
987bool operator >(const scifir::scalar_unit& x, const scifir::scalar_unit& y)
988{
989 if(!x.has_dimensions(y))
990 {
991 return false;
992 }
993 scifir::scalar_unit z = x;
994 z.change_dimensions(y);
995 if(z.get_value() > y.get_value())
996 {
997 return true;
998 }
999 else
1000 {
1001 return false;
1002 }
1003}
1004
1005bool operator <=(const scifir::scalar_unit& x, const scifir::scalar_unit& y)
1006{
1007 return !(x > y);
1008}
1009
1010bool operator >=(const scifir::scalar_unit& x, const scifir::scalar_unit& y)
1011{
1012 return !(x < y);
1013}
1014
1015bool operator ==(const scifir::scalar_unit& x, const string& init_scalar)
1016{
1017 scifir::scalar_unit y(init_scalar);
1018 return (x == y);
1019}
1020
1021bool operator !=(const scifir::scalar_unit& x, const string& init_scalar)
1022{
1023 return !(x == init_scalar);
1024}
1025
1026bool operator <(const scifir::scalar_unit& x, const string& init_scalar)
1027{
1028 scifir::scalar_unit y(init_scalar);
1029 return (x < y);
1030}
1031
1032bool operator >(const scifir::scalar_unit& x, const string& init_scalar)
1033{
1034 scifir::scalar_unit y(init_scalar);
1035 return (x > y);
1036}
1037
1038bool operator <=(const scifir::scalar_unit& x, const string& init_scalar)
1039{
1040 return !(x > init_scalar);
1041}
1042
1043bool operator >=(const scifir::scalar_unit& x, const string& init_scalar)
1044{
1045 return !(x < init_scalar);
1046}
1047
1048bool operator ==(const string& init_scalar, const scifir::scalar_unit& x)
1049{
1050 return (x == init_scalar);
1051}
1052
1053bool operator !=(const string& init_scalar, const scifir::scalar_unit& x)
1054{
1055 return (x != init_scalar);
1056}
1057
1058bool operator <(const string& init_scalar, const scifir::scalar_unit& x)
1059{
1060 scifir::scalar_unit y(init_scalar);
1061 return (y < x);
1062}
1063
1064bool operator >(const string& init_scalar, const scifir::scalar_unit& x)
1065{
1066 scifir::scalar_unit y(init_scalar);
1067 return (y > x);
1068}
1069
1070bool operator <=(const string& init_scalar, const scifir::scalar_unit& x)
1071{
1072 return !(init_scalar > x);
1073}
1074
1075bool operator >=(const string& init_scalar, const scifir::scalar_unit& x)
1076{
1077 return !(init_scalar < x);
1078}
1079
1080void operator +=(string& x, const scifir::scalar_unit& y)
1081{
1082 ostringstream output;
1083 output << y;
1084 x += output.str();
1085}
1086
1087string operator +(const string& x, const scifir::scalar_unit& y)
1088{
1089 ostringstream output;
1090 output << x;
1091 output << y;
1092 return output.str();
1093}
1094
1095string operator +(const scifir::scalar_unit& y, const string& x)
1096{
1097 ostringstream output;
1098 output << y;
1099 output << x;
1100 return output.str();
1101}
1102
1103ostream& operator <<(ostream& os, const scifir::scalar_unit& x)
1104{
1105 return os << to_string(x);
1106}
1107
1108istream& operator >>(istream& is, scifir::scalar_unit& x)
1109{
1110 char a[256];
1111 is.getline(a, 256);
1112 string b(a);
1113 boost::trim(b);
1114 x = scifir::scalar_unit(b);
1115 return is;
1116}
base_units.hpp
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::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::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::NONE
@ NONE
No dimension. Default value for the default constructor.
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::KELVIN
@ KELVIN
Kelvin, plural kelvins. SI dimension of temperature. Symbol K.
Definition dimension.hpp:35
scifir::prefix
Class that represents prefixes of the SI system of units. Each prefix sizes 1 byte....
Definition prefix.hpp:14
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::scalar_unit
Class that allows to create scalar units, which are composed of a value (as a float) and dimensions....
Definition scalar_unit.hpp:202
scifir::scalar_unit::to_latex
string to_latex(const string &init_dimensions, int number_of_decimals=2, bool with_brackets=false) const
Definition scalar_unit.cpp:581
scifir::scalar_unit::has_single_dimensions
bool has_single_dimensions() const
Returns true if there's only one dimension, which can be simple or composite.
Definition scalar_unit.cpp:398
scifir::scalar_unit::has_empty_dimensions
bool has_empty_dimensions() const
Checks if there aren't base dimensions.
Definition scalar_unit.cpp:355
scifir::scalar_unit::display_dimensions
string display_dimensions() const
Generates an string of the dimensions of the scalar_unit, with the same format as the initialization ...
Definition scalar_unit.cpp:419
scifir::scalar_unit::operator--
scalar_unit & operator--()
Decrement operator, it decreases the value by one.
Definition scalar_unit.cpp:221
scifir::scalar_unit::has_composite_dimensions
bool has_composite_dimensions() const
Returns true is there's more than one simple dimension.
Definition scalar_unit.cpp:403
scifir::scalar_unit::add_dimension
void add_dimension(const dimension &new_dimension)
Internal function. It adds a dimension, changing the value according to the conversion factor of the ...
Definition scalar_unit.cpp:664
scifir::scalar_unit::dimensions
vector< dimension > dimensions
Dimensions of the scalar_unit. They can be simple dimensions, composite dimensions or special names.
Definition scalar_unit.hpp:338
scifir::scalar_unit::operator=
scalar_unit & operator=(const scalar_unit &x)
Copy assignment, it assigns a copy of the scalar_unit.
Definition scalar_unit.cpp:73
scifir::scalar_unit::operator*
scalar_unit operator*(scalar_unit x) const
Multiplication operator, it multiplies two scalar_unit classes, their dimensions are also multiplied.
Definition scalar_unit.cpp:157
scifir::scalar_unit::get_dimensions
const vector< dimension > & get_dimensions() const
Read-only getter of the dimensions.
Definition scalar_unit.hpp:321
scifir::scalar_unit::operator==
bool operator==(scalar_unit x) const
Comparison operator, two scalar_unit classes are considered equivalent if they have the same value gi...
Definition scalar_unit.cpp:112
scifir::scalar_unit::operator/
scalar_unit operator/(scalar_unit x) const
Division operator, it divides one scalar_unit class with the other, their dimensions are also divided...
Definition scalar_unit.cpp:165
scifir::scalar_unit::has_dimensions
bool has_dimensions(const string &init_dimensions) const
Checks if the basic dimensions are the same as the initialization string of dimensions.
Definition scalar_unit.cpp:339
scifir::scalar_unit::check_dimensions
void check_dimensions(const vector< dimension > &real_dimensions)
Definition scalar_unit.cpp:731
scifir::scalar_unit::get_single_dimension_type
dimension::type get_single_dimension_type() const
Returns the dimension::type if there's only one dimension, returns dimension::NONE if there's more th...
Definition scalar_unit.cpp:429
scifir::scalar_unit::display
string display(int number_of_decimals=2, bool with_brackets=false, bool use_close_prefix=false) const
Generates a string representation of the scalar_unit, with the value and the dimensions....
Definition scalar_unit.cpp:446
scifir::scalar_unit::get_base_dimensions
vector< dimension > get_base_dimensions() const
Generates a set of the base dimensions of the dimensions of the scalar_unit.
Definition scalar_unit.cpp:441
scifir::scalar_unit::value
float value
Value of the scalar_unit. It changes automatically when the dimensions change.
Definition scalar_unit.hpp:339
scifir::scalar_unit::is_dimensionless
bool is_dimensionless() const
Returns true if there aren't dimensions or if all dimensions are dimensionless.
Definition scalar_unit.cpp:367
scifir::scalar_unit::operator+
scalar_unit operator+(scalar_unit x) const
Addition operator, it sums two scalar_unit classes, their dimensions are changed to be equal first....
Definition scalar_unit.cpp:125
scifir::scalar_unit::operator++
scalar_unit & operator++()
Increment operator, it increases the value by one.
Definition scalar_unit.cpp:208
scifir::scalar_unit::has_simple_dimensions
bool has_simple_dimensions() const
Returns true if there's only a simple dimension.
Definition scalar_unit.cpp:386
scifir::scalar_unit::operator-
scalar_unit operator-(scalar_unit x) const
Substraction operator, it substracts one scalar_unit from the other, their dimensions are changed to ...
Definition scalar_unit.cpp:141
scifir::scalar_unit::change_dimensions
void change_dimensions(const string &init_dimensions)
Changes the dimensions to the dimensions specified by the initialization string of dimensions.
Definition scalar_unit.cpp:234
scifir::scalar_unit::scalar_unit
scalar_unit()
Default constructor, the value is 0 and the dimensions are empty.
Definition scalar_unit.cpp:23
scifir::scalar_unit::operator+=
void operator+=(scalar_unit x)
Addition operator, it adds a scalar_unit class to another, by converting their dimensions to be equal...
Definition scalar_unit.cpp:186
scifir::scalar_unit::initialize_from_string
void initialize_from_string(string init_scalar, const vector< dimension > &real_dimensions)
Internal function. It sets the value and the dimensions of the scalar_unit to the value and dimension...
Definition scalar_unit.cpp:692
scifir::scalar_unit::custom_display
string custom_display(const string &init_dimensions, int number_of_decimals=2, bool with_brackets=false) const
Generates a string representation of the scalar_unit, with the dimensions changed to any set of dimen...
Definition scalar_unit.cpp:497
scifir::scalar_unit::operator-=
void operator-=(scalar_unit x)
Substraction operator, it substracts a scalar_unit class to another, by converting their dimensions t...
Definition scalar_unit.cpp:197
scifir::scalar_unit::base_display
string base_display(int number_of_decimals=2, bool with_brackets=false, bool use_close_prefix=false) const
Generates a string representation of the scalar_unit, with its dimensions converted to their base cou...
Definition scalar_unit.cpp:475
scifir::scalar_unit::remove_dimension
void remove_dimension(const dimension &old_dimension)
Internal function. It removes a dimension, changing the value according to the conversion factor of t...
Definition scalar_unit.cpp:678
scifir::scalar_unit::get_value
const float & get_value() const
Read-only getter of the value.
Definition scalar_unit.hpp:326
scifir::scalar_unit::operator^
scalar_unit operator^(const scalar_unit &x) const
Power operator, it powers a scalar_unit class with another, if that second scalar_unit class,...
Definition scalar_unit.cpp:173
scifir
The namespace scifir contains all scifir-units, excepting the string literals, which are outside.
Definition address.cpp:6
scifir::sqrt_nth
angle sqrt_nth(const angle &x, int index)
Calculates the nth root of the angle x and returns that new angle.
Definition angle.cpp:421
scifir::abs
T abs(const complex_number< T > &x)
Definition complex_number.hpp:186
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::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::is_scalar_unit
bool is_scalar_unit(const string &init_scalar)
Checks if an string is an initialization string of a scalar_unit.
Definition scalar_unit.cpp:745
scifir::closest_prefix
prefix closest_prefix(const prefix &actual_prefix, int actual_scale)
Returns the closes prefix related to the scale of the current value. It is used when displaying a sca...
Definition prefix.cpp:323
scifir::pow
scalar_unit pow(const scalar_unit &x, int exponent)
Exponentiates a scalar_unit to some numeric type, the dimensions are also exponentiated.
Definition scalar_unit.cpp:942
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::display_float
string display_float(const float &value, int number_of_decimals)
Definition types.cpp:36
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::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::sqrt
angle sqrt(const angle &x)
Calculates the square root of the angle x and returns that new angle.
Definition angle.cpp:416
scifir::power_dimensions
vector< dimension > power_dimensions(const vector< dimension > &x, int exponent)
Powers the dimensions by an exponent.
Definition dimension.cpp:2190
operator<=
bool operator<=(const scifir::scalar_unit &x, const scifir::scalar_unit &y)
Returns true if x has a lower or equal value than y, compared with the same dimensions....
Definition scalar_unit.cpp:1005
operator>>
istream & operator>>(istream &is, scifir::scalar_unit &x)
Allows that an istream initializes by string a scalar_unit x.
Definition scalar_unit.cpp:1108
operator>
bool operator>(const scifir::scalar_unit &x, const scifir::scalar_unit &y)
Returns true if x has a greather value than y, compared with the same dimensions. If their dimensions...
Definition scalar_unit.cpp:987
operator+
string operator+(const string &x, const scifir::scalar_unit &y)
Creates a new string as the concatenation of the string x with the representation string of the scala...
Definition scalar_unit.cpp:1087
operator!=
bool operator!=(const scifir::scalar_unit &x, scifir::scalar_unit y)
Returns true if two scalar_unit classes doesn't have the same value when changed to same dimensions....
Definition scalar_unit.cpp:964
operator<<
ostream & operator<<(ostream &os, const scifir::scalar_unit &x)
Adds the string representation of the scalar_unit x to an output stream os.
Definition scalar_unit.cpp:1103
operator+=
void operator+=(string &x, const scifir::scalar_unit &y)
Concatenates the string representation of the scalar_unit y to the string x.
Definition scalar_unit.cpp:1080
operator==
bool operator==(const scifir::scalar_unit &x, const string &init_scalar)
Returns true if x is equal to the scalar_unit initialized with the string being compared....
Definition scalar_unit.cpp:1015
operator<
bool operator<(const scifir::scalar_unit &x, const scifir::scalar_unit &y)
Returns true if x has a lower value than y, compared with the same dimensions. If their dimensions ar...
Definition scalar_unit.cpp:969
operator>=
bool operator>=(const scifir::scalar_unit &x, const scifir::scalar_unit &y)
Returns true if x has a greather or equal value than y, compared with the same dimensions....
Definition scalar_unit.cpp:1010
scalar_unit.hpp
Generated by doxygen 1.9.8