ad_physics
RatioOperation.hpp
Go to the documentation of this file.
1 // ----------------- BEGIN LICENSE BLOCK ---------------------------------
2 //
3 // Copyright (C) 2020-2021 Intel Corporation
4 //
5 // SPDX-License-Identifier: MIT
6 //
7 // ----------------- END LICENSE BLOCK -----------------------------------
8 
13 #pragma once
14 
15 #include "ad/physics/Types.hpp"
16 
17 /* ################## ad::physics::Acceleration ################ */
18 
30 inline ad::physics::Acceleration operator*(ad::physics::Acceleration const &value, ad::physics::RatioValue const &r)
31 {
32  r.ensureValid();
33  value.ensureValid();
34  ad::physics::Acceleration const result(static_cast<double>(r) * static_cast<double>(value));
35  result.ensureValid();
36  return result;
37 }
38 
50 inline ad::physics::Acceleration operator*(ad::physics::RatioValue const &r, ad::physics::Acceleration const &value)
51 {
52  return operator*(value, r);
53 }
54 
66 inline ad::physics::Acceleration operator/(ad::physics::Acceleration const &value, ad::physics::RatioValue const &r)
67 {
68  r.ensureValidNonZero();
69  value.ensureValid();
70  ad::physics::Acceleration const result(static_cast<double>(value) / static_cast<double>(r));
71  result.ensureValid();
72  return result;
73 }
74 
75 /* ################## ad::physics::Angle ################ */
76 
88 inline ad::physics::Angle operator*(ad::physics::Angle const &value, ad::physics::RatioValue const &r)
89 {
90  r.ensureValid();
91  value.ensureValid();
92  ad::physics::Angle const result(static_cast<double>(r) * static_cast<double>(value));
93  result.ensureValid();
94  return result;
95 }
96 
108 inline ad::physics::Angle operator*(ad::physics::RatioValue const &r, ad::physics::Angle const &value)
109 {
110  return operator*(value, r);
111 }
112 
124 inline ad::physics::Angle operator/(ad::physics::Angle const &value, ad::physics::RatioValue const &r)
125 {
126  r.ensureValidNonZero();
127  value.ensureValid();
128  ad::physics::Angle const result(static_cast<double>(value) / static_cast<double>(r));
129  result.ensureValid();
130  return result;
131 }
132 
133 /* ################## ad::physics::AngularAcceleration ################ */
134 
146 inline ad::physics::AngularAcceleration operator*(ad::physics::AngularAcceleration const &value,
147  ad::physics::RatioValue const &r)
148 {
149  r.ensureValid();
150  value.ensureValid();
151  ad::physics::AngularAcceleration const result(static_cast<double>(r) * static_cast<double>(value));
152  result.ensureValid();
153  return result;
154 }
155 
167 inline ad::physics::AngularAcceleration operator*(ad::physics::RatioValue const &r,
168  ad::physics::AngularAcceleration const &value)
169 {
170  return operator*(value, r);
171 }
172 
184 inline ad::physics::AngularAcceleration operator/(ad::physics::AngularAcceleration const &value,
185  ad::physics::RatioValue const &r)
186 {
187  r.ensureValidNonZero();
188  value.ensureValid();
189  ad::physics::AngularAcceleration const result(static_cast<double>(value) / static_cast<double>(r));
190  result.ensureValid();
191  return result;
192 }
193 
194 /* ################## ad::physics::AngularVelocity ################ */
195 
207 inline ad::physics::AngularVelocity operator*(ad::physics::AngularVelocity const &value,
208  ad::physics::RatioValue const &r)
209 {
210  r.ensureValid();
211  value.ensureValid();
212  ad::physics::AngularVelocity const result(static_cast<double>(r) * static_cast<double>(value));
213  result.ensureValid();
214  return result;
215 }
216 
228 inline ad::physics::AngularVelocity operator*(ad::physics::RatioValue const &r,
229  ad::physics::AngularVelocity const &value)
230 {
231  return operator*(value, r);
232 }
233 
245 inline ad::physics::AngularVelocity operator/(ad::physics::AngularVelocity const &value,
246  ad::physics::RatioValue const &r)
247 {
248  r.ensureValidNonZero();
249  value.ensureValid();
250  ad::physics::AngularVelocity const result(static_cast<double>(value) / static_cast<double>(r));
251  result.ensureValid();
252  return result;
253 }
254 
255 /* ################## ad::physics::Distance ################ */
256 
268 inline ad::physics::Distance operator*(ad::physics::Distance const &value, ad::physics::RatioValue const &r)
269 {
270  r.ensureValid();
271  value.ensureValid();
272  ad::physics::Distance const result(static_cast<double>(r) * static_cast<double>(value));
273  result.ensureValid();
274  return result;
275 }
276 
288 inline ad::physics::Distance operator*(ad::physics::RatioValue const &r, ad::physics::Distance const &value)
289 {
290  return operator*(value, r);
291 }
292 
304 inline ad::physics::Distance operator/(ad::physics::Distance const &value, ad::physics::RatioValue const &r)
305 {
306  r.ensureValidNonZero();
307  value.ensureValid();
308  ad::physics::Distance const result(static_cast<double>(value) / static_cast<double>(r));
309  result.ensureValid();
310  return result;
311 }
312 
313 /* ################## ad::physics::DistanceSquared ################ */
314 
326 inline ad::physics::DistanceSquared operator*(ad::physics::DistanceSquared const &value,
327  ad::physics::RatioValue const &r)
328 {
329  r.ensureValid();
330  value.ensureValid();
331  ad::physics::DistanceSquared const result(static_cast<double>(r) * static_cast<double>(value));
332  result.ensureValid();
333  return result;
334 }
335 
347 inline ad::physics::DistanceSquared operator*(ad::physics::RatioValue const &r,
348  ad::physics::DistanceSquared const &value)
349 {
350  return operator*(value, r);
351 }
352 
364 inline ad::physics::DistanceSquared operator/(ad::physics::DistanceSquared const &value,
365  ad::physics::RatioValue const &r)
366 {
367  r.ensureValidNonZero();
368  value.ensureValid();
369  ad::physics::DistanceSquared const result(static_cast<double>(value) / static_cast<double>(r));
370  result.ensureValid();
371  return result;
372 }
373 
374 /* ################## ad::physics::Duration ################ */
375 
387 inline ad::physics::Duration operator*(ad::physics::Duration const &value, ad::physics::RatioValue const &r)
388 {
389  r.ensureValid();
390  value.ensureValid();
391  ad::physics::Duration const result(static_cast<double>(r) * static_cast<double>(value));
392  result.ensureValid();
393  return result;
394 }
395 
407 inline ad::physics::Duration operator*(ad::physics::RatioValue const &r, ad::physics::Duration const &value)
408 {
409  return operator*(value, r);
410 }
411 
423 inline ad::physics::Duration operator/(ad::physics::Duration const &value, ad::physics::RatioValue const &r)
424 {
425  r.ensureValidNonZero();
426  value.ensureValid();
427  ad::physics::Duration const result(static_cast<double>(value) / static_cast<double>(r));
428  result.ensureValid();
429  return result;
430 }
431 
432 /* ################## ad::physics::DurationSquared ################ */
433 
445 inline ad::physics::DurationSquared operator*(ad::physics::DurationSquared const &value,
446  ad::physics::RatioValue const &r)
447 {
448  r.ensureValid();
449  value.ensureValid();
450  ad::physics::DurationSquared const result(static_cast<double>(r) * static_cast<double>(value));
451  result.ensureValid();
452  return result;
453 }
454 
466 inline ad::physics::DurationSquared operator*(ad::physics::RatioValue const &r,
467  ad::physics::DurationSquared const &value)
468 {
469  return operator*(value, r);
470 }
471 
483 inline ad::physics::DurationSquared operator/(ad::physics::DurationSquared const &value,
484  ad::physics::RatioValue const &r)
485 {
486  r.ensureValidNonZero();
487  value.ensureValid();
488  ad::physics::DurationSquared const result(static_cast<double>(value) / static_cast<double>(r));
489  result.ensureValid();
490  return result;
491 }
492 
493 /* ################## ad::physics::ParametricValue ################ */
494 
506 inline ad::physics::ParametricValue operator*(ad::physics::ParametricValue const &value,
507  ad::physics::RatioValue const &r)
508 {
509  value.ensureValid();
510  r.ensureValid();
511  ad::physics::ParametricValue const result(static_cast<double>(value) * static_cast<double>(r));
512  result.ensureValid();
513  return result;
514 }
515 
527 inline ad::physics::ParametricValue operator/(ad::physics::ParametricValue const &value,
528  ad::physics::RatioValue const &r)
529 {
530  r.ensureValidNonZero();
531  value.ensureValid();
532  ad::physics::ParametricValue const result(static_cast<double>(value) / static_cast<double>(r));
533  result.ensureValid();
534  return result;
535 }
536 
537 /* ################## ad::physics::Probability ################ */
538 
550 inline ad::physics::Probability operator*(ad::physics::Probability const &value, ad::physics::RatioValue const &r)
551 {
552  r.ensureValid();
553  value.ensureValid();
554  ad::physics::Probability const result(static_cast<double>(r) * static_cast<double>(value));
555  result.ensureValid();
556  return result;
557 }
558 
570 inline ad::physics::Probability operator*(ad::physics::RatioValue const &r, ad::physics::Probability const &value)
571 {
572  return operator*(value, r);
573 }
574 
586 inline ad::physics::Probability operator/(ad::physics::Probability const &value, ad::physics::RatioValue const &r)
587 {
588  r.ensureValidNonZero();
589  value.ensureValid();
590  ad::physics::Probability const result(static_cast<double>(value) / static_cast<double>(r));
591  result.ensureValid();
592  return result;
593 }
594 
595 /* ################## ad::physics::RatioValue ################ */
596 
608 inline ad::physics::RatioValue operator*(ad::physics::RatioValue const &r1, ad::physics::RatioValue const &r2)
609 {
610  r1.ensureValid();
611  r2.ensureValid();
612  ad::physics::RatioValue const result(static_cast<double>(r1) * static_cast<double>(r2));
613  result.ensureValid();
614  return result;
615 }
616 
617 /* ################## ad::physics::Speed ################ */
618 
630 inline ad::physics::Speed operator*(ad::physics::Speed const &value, ad::physics::RatioValue const &r)
631 {
632  r.ensureValid();
633  value.ensureValid();
634  ad::physics::Speed const result(static_cast<double>(r) * static_cast<double>(value));
635  result.ensureValid();
636  return result;
637 }
638 
650 inline ad::physics::Speed operator*(ad::physics::RatioValue const &r, ad::physics::Speed const &value)
651 {
652  return operator*(value, r);
653 }
654 
666 inline ad::physics::Speed operator/(ad::physics::Speed const &value, ad::physics::RatioValue const &r)
667 {
668  r.ensureValidNonZero();
669  value.ensureValid();
670  ad::physics::Speed const result(static_cast<double>(value) / static_cast<double>(r));
671  result.ensureValid();
672  return result;
673 }
674 
675 /* ################## ad::physics::SpeedSquared ################ */
676 
688 inline ad::physics::SpeedSquared operator*(ad::physics::SpeedSquared const &value, ad::physics::RatioValue const &r)
689 {
690  r.ensureValid();
691  value.ensureValid();
692  ad::physics::SpeedSquared const result(static_cast<double>(r) * static_cast<double>(value));
693  result.ensureValid();
694  return result;
695 }
696 
708 inline ad::physics::SpeedSquared operator*(ad::physics::RatioValue const &r, ad::physics::SpeedSquared const &value)
709 {
710  return operator*(value, r);
711 }
712 
724 inline ad::physics::SpeedSquared operator/(ad::physics::SpeedSquared const &value, ad::physics::RatioValue const &r)
725 {
726  r.ensureValidNonZero();
727  value.ensureValid();
728  ad::physics::SpeedSquared const result(static_cast<double>(value) / static_cast<double>(r));
729  result.ensureValid();
730  return result;
731 }
732 
733 /* ################## ad::physics::Weight ################ */
734 
746 inline ad::physics::Weight operator*(ad::physics::Weight const &value, ad::physics::RatioValue const &r)
747 {
748  r.ensureValid();
749  value.ensureValid();
750  ad::physics::Weight const result(static_cast<double>(r) * static_cast<double>(value));
751  result.ensureValid();
752  return result;
753 }
754 
766 inline ad::physics::Weight operator*(ad::physics::RatioValue const &r, ad::physics::Weight const &value)
767 {
768  return operator*(value, r);
769 }
770 
782 inline ad::physics::Weight operator/(ad::physics::Weight const &value, ad::physics::RatioValue const &r)
783 {
784  r.ensureValidNonZero();
785  value.ensureValid();
786  ad::physics::Weight const result(static_cast<double>(value) / static_cast<double>(r));
787  result.ensureValid();
788  return result;
789 }
ad::physics::Distance
DataType Distance.
Definition: Distance.hpp:67
ad::physics::Angle
DataType Angle.
Definition: Angle.hpp:59
ad::physics::AngularVelocity::ensureValid
void ensureValid() const
ensure that the AngularVelocity is valid
Definition: AngularVelocity.hpp:395
ad::physics::DistanceSquared
DataType DistanceSquared.
Definition: DistanceSquared.hpp:67
ad::physics::Speed
DataType Speed.
Definition: Speed.hpp:68
ad::physics::Distance::ensureValid
void ensureValid() const
ensure that the Distance is valid
Definition: Distance.hpp:416
ad::physics::RatioValue
DataType RatioValue.
Definition: RatioValue.hpp:59
ad::physics::AngularAcceleration::ensureValid
void ensureValid() const
ensure that the AngularAcceleration is valid
Definition: AngularAcceleration.hpp:396
ad::physics::Duration::ensureValid
void ensureValid() const
ensure that the Duration is valid
Definition: Duration.hpp:416
ad::physics::Speed::ensureValid
void ensureValid() const
ensure that the Speed is valid
Definition: Speed.hpp:416
ad::physics::DurationSquared
DataType DurationSquared.
Definition: DurationSquared.hpp:67
ad::physics::Probability::ensureValid
void ensureValid() const
ensure that the Probability is valid
Definition: Probability.hpp:394
ad::physics::AngularAcceleration
DataType AngularAcceleration.
Definition: AngularAcceleration.hpp:59
ad::physics::Probability
DataType Probability.
Definition: Probability.hpp:58
operator/
ad::physics::Acceleration operator/(ad::physics::Acceleration const &value, ad::physics::RatioValue const &r)
Arithmetic physics operation value = value / r.
Definition: RatioOperation.hpp:66
ad::physics::Angle::ensureValid
void ensureValid() const
ensure that the Angle is valid
Definition: Angle.hpp:394
ad::physics::SpeedSquared::ensureValid
void ensureValid() const
ensure that the SpeedSquared is valid
Definition: SpeedSquared.hpp:403
ad::physics::ParametricValue
DataType ParametricValue.
Definition: ParametricValue.hpp:59
ad::physics::Acceleration
DataType Acceleration.
Definition: Acceleration.hpp:59
Types.hpp
ad::physics::Weight
DataType Weight.
Definition: Weight.hpp:59
ad::physics::SpeedSquared
DataType SpeedSquared.
Definition: SpeedSquared.hpp:67
ad::physics::RatioValue::ensureValidNonZero
void ensureValidNonZero() const
ensure that the RatioValue is valid and non zero
Definition: RatioValue.hpp:412
ad::physics::Duration
DataType Duration.
Definition: Duration.hpp:67
ad::physics::AngularVelocity
DataType AngularVelocity.
Definition: AngularVelocity.hpp:59
ad::physics::RatioValue::ensureValid
void ensureValid() const
ensure that the RatioValue is valid
Definition: RatioValue.hpp:395
ad::physics::ParametricValue::ensureValid
void ensureValid() const
ensure that the ParametricValue is valid
Definition: ParametricValue.hpp:395
operator*
ad::physics::Acceleration operator*(ad::physics::Acceleration const &value, ad::physics::RatioValue const &r)
Arithmetic physics operation value = value * r.
Definition: RatioOperation.hpp:30
ad::physics::Weight::ensureValid
void ensureValid() const
ensure that the Weight is valid
Definition: Weight.hpp:394
ad::physics::DistanceSquared::ensureValid
void ensureValid() const
ensure that the DistanceSquared is valid
Definition: DistanceSquared.hpp:403
ad::physics::Acceleration::ensureValid
void ensureValid() const
ensure that the Acceleration is valid
Definition: Acceleration.hpp:395
ad::physics::DurationSquared::ensureValid
void ensureValid() const
ensure that the DurationSquared is valid
Definition: DurationSquared.hpp:403
Generated by   doxygen 1.8.17