ad_physics
ParametricOperation.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,
31  ad::physics::ParametricValue const &p)
32 {
33  p.ensureValid();
34  value.ensureValid();
35  ad::physics::Acceleration const result(static_cast<double>(p) * static_cast<double>(value));
36  result.ensureValid();
37  return result;
38 }
39 
51 inline ad::physics::Acceleration operator*(ad::physics::ParametricValue const &p,
52  ad::physics::Acceleration const &value)
53 {
54  return operator*(value, p);
55 }
56 
68 inline ad::physics::Acceleration operator/(ad::physics::Acceleration const &value,
69  ad::physics::ParametricValue const &p)
70 {
71  p.ensureValidNonZero();
72  value.ensureValid();
73  ad::physics::Acceleration const result(static_cast<double>(value) / static_cast<double>(p));
74  result.ensureValid();
75  return result;
76 }
77 
78 /* ################## ad::physics::Angle ################ */
79 
91 inline ad::physics::Angle operator*(ad::physics::Angle const &value, ad::physics::ParametricValue const &p)
92 {
93  p.ensureValid();
94  value.ensureValid();
95  ad::physics::Angle const result(static_cast<double>(p) * static_cast<double>(value));
96  result.ensureValid();
97  return result;
98 }
99 
111 inline ad::physics::Angle operator*(ad::physics::ParametricValue const &p, ad::physics::Angle const &value)
112 {
113  return operator*(value, p);
114 }
115 
127 inline ad::physics::Angle operator/(ad::physics::Angle const &value, ad::physics::ParametricValue const &p)
128 {
129  p.ensureValidNonZero();
130  value.ensureValid();
131  ad::physics::Angle const result(static_cast<double>(value) / static_cast<double>(p));
132  result.ensureValid();
133  return result;
134 }
135 
136 /* ################## ad::physics::AngularAcceleration ################ */
137 
149 inline ad::physics::AngularAcceleration operator*(ad::physics::AngularAcceleration const &value,
150  ad::physics::ParametricValue const &p)
151 {
152  p.ensureValid();
153  value.ensureValid();
154  ad::physics::AngularAcceleration const result(static_cast<double>(p) * static_cast<double>(value));
155  result.ensureValid();
156  return result;
157 }
158 
170 inline ad::physics::AngularAcceleration operator*(ad::physics::ParametricValue const &p,
171  ad::physics::AngularAcceleration const &value)
172 {
173  return operator*(value, p);
174 }
175 
187 inline ad::physics::AngularAcceleration operator/(ad::physics::AngularAcceleration const &value,
188  ad::physics::ParametricValue const &p)
189 {
190  p.ensureValidNonZero();
191  value.ensureValid();
192  ad::physics::AngularAcceleration const result(static_cast<double>(value) / static_cast<double>(p));
193  result.ensureValid();
194  return result;
195 }
196 
197 /* ################## ad::physics::AngularVelocity ################ */
198 
210 inline ad::physics::AngularVelocity operator*(ad::physics::AngularVelocity const &value,
211  ad::physics::ParametricValue const &p)
212 {
213  p.ensureValid();
214  value.ensureValid();
215  ad::physics::AngularVelocity const result(static_cast<double>(p) * static_cast<double>(value));
216  result.ensureValid();
217  return result;
218 }
219 
231 inline ad::physics::AngularVelocity operator*(ad::physics::ParametricValue const &p,
232  ad::physics::AngularVelocity const &value)
233 {
234  return operator*(value, p);
235 }
236 
248 inline ad::physics::AngularVelocity operator/(ad::physics::AngularVelocity const &value,
249  ad::physics::ParametricValue const &p)
250 {
251  p.ensureValidNonZero();
252  value.ensureValid();
253  ad::physics::AngularVelocity const result(static_cast<double>(value) / static_cast<double>(p));
254  result.ensureValid();
255  return result;
256 }
257 
258 /* ################## ad::physics::Distance ################ */
259 
271 inline ad::physics::Distance operator*(ad::physics::Distance const &value, ad::physics::ParametricValue const &p)
272 {
273  p.ensureValid();
274  value.ensureValid();
275  ad::physics::Distance const result(static_cast<double>(p) * static_cast<double>(value));
276  result.ensureValid();
277  return result;
278 }
279 
291 inline ad::physics::Distance operator*(ad::physics::ParametricValue const &p, ad::physics::Distance const &value)
292 {
293  return operator*(value, p);
294 }
295 
307 inline ad::physics::Distance operator/(ad::physics::Distance const &value, ad::physics::ParametricValue const &p)
308 {
309  p.ensureValidNonZero();
310  value.ensureValid();
311  ad::physics::Distance const result(static_cast<double>(value) / static_cast<double>(p));
312  result.ensureValid();
313  return result;
314 }
315 
316 /* ################## ad::physics::DistanceSquared ################ */
317 
329 inline ad::physics::DistanceSquared operator*(ad::physics::DistanceSquared const &value,
330  ad::physics::ParametricValue const &p)
331 {
332  p.ensureValid();
333  value.ensureValid();
334  ad::physics::DistanceSquared const result(static_cast<double>(p) * static_cast<double>(value));
335  result.ensureValid();
336  return result;
337 }
338 
350 inline ad::physics::DistanceSquared operator*(ad::physics::ParametricValue const &p,
351  ad::physics::DistanceSquared const &value)
352 {
353  return operator*(value, p);
354 }
355 
367 inline ad::physics::DistanceSquared operator/(ad::physics::DistanceSquared const &value,
368  ad::physics::ParametricValue const &p)
369 {
370  p.ensureValidNonZero();
371  value.ensureValid();
372  ad::physics::DistanceSquared const result(static_cast<double>(value) / static_cast<double>(p));
373  result.ensureValid();
374  return result;
375 }
376 
377 /* ################## ad::physics::Duration ################ */
378 
390 inline ad::physics::Duration operator*(ad::physics::Duration const &value, ad::physics::ParametricValue const &p)
391 {
392  p.ensureValid();
393  value.ensureValid();
394  ad::physics::Duration const result(static_cast<double>(p) * static_cast<double>(value));
395  result.ensureValid();
396  return result;
397 }
398 
410 inline ad::physics::Duration operator*(ad::physics::ParametricValue const &p, ad::physics::Duration const &value)
411 {
412  return operator*(value, p);
413 }
414 
426 inline ad::physics::Duration operator/(ad::physics::Duration const &value, ad::physics::ParametricValue const &p)
427 {
428  p.ensureValidNonZero();
429  value.ensureValid();
430  ad::physics::Duration const result(static_cast<double>(value) / static_cast<double>(p));
431  result.ensureValid();
432  return result;
433 }
434 
435 /* ################## ad::physics::DurationSquared ################ */
436 
448 inline ad::physics::DurationSquared operator*(ad::physics::DurationSquared const &value,
449  ad::physics::ParametricValue const &p)
450 {
451  p.ensureValid();
452  value.ensureValid();
453  ad::physics::DurationSquared const result(static_cast<double>(p) * static_cast<double>(value));
454  result.ensureValid();
455  return result;
456 }
457 
469 inline ad::physics::DurationSquared operator*(ad::physics::ParametricValue const &p,
470  ad::physics::DurationSquared const &value)
471 {
472  return operator*(value, p);
473 }
474 
486 inline ad::physics::DurationSquared operator/(ad::physics::DurationSquared const &value,
487  ad::physics::ParametricValue const &p)
488 {
489  p.ensureValidNonZero();
490  value.ensureValid();
491  ad::physics::DurationSquared const result(static_cast<double>(value) / static_cast<double>(p));
492  result.ensureValid();
493  return result;
494 }
495 
496 /* ################## ad::physics::ParametricValue ################ */
497 
509 inline ad::physics::ParametricValue operator*(ad::physics::ParametricValue const &p1,
510  ad::physics::ParametricValue const &p2)
511 {
512  p1.ensureValid();
513  p2.ensureValid();
514  ad::physics::ParametricValue const result(static_cast<double>(p1) * static_cast<double>(p2));
515  result.ensureValid();
516  return result;
517 }
518 
519 /* ################## ad::physics::Probability ################ */
520 
532 inline ad::physics::Probability operator*(ad::physics::Probability const &value, ad::physics::ParametricValue const &p)
533 {
534  p.ensureValid();
535  value.ensureValid();
536  ad::physics::Probability const result(static_cast<double>(p) * static_cast<double>(value));
537  result.ensureValid();
538  return result;
539 }
540 
552 inline ad::physics::Probability operator*(ad::physics::ParametricValue const &p, ad::physics::Probability const &value)
553 {
554  return operator*(value, p);
555 }
556 
568 inline ad::physics::Probability operator/(ad::physics::Probability const &value, ad::physics::ParametricValue const &p)
569 {
570  p.ensureValidNonZero();
571  value.ensureValid();
572  ad::physics::Probability const result(static_cast<double>(value) / static_cast<double>(p));
573  result.ensureValid();
574  return result;
575 }
576 
577 /* ################## ad::physics::RatioValue ################ */
578 
590 inline ad::physics::RatioValue operator*(ad::physics::RatioValue const &value, ad::physics::ParametricValue const &p)
591 {
592  p.ensureValid();
593  value.ensureValid();
594  ad::physics::RatioValue const result(static_cast<double>(p) * static_cast<double>(value));
595  result.ensureValid();
596  return result;
597 }
598 
610 inline ad::physics::RatioValue operator/(ad::physics::RatioValue const &value, ad::physics::ParametricValue const &p)
611 {
612  p.ensureValidNonZero();
613  value.ensureValid();
614  ad::physics::RatioValue const result(static_cast<double>(value) / static_cast<double>(p));
615  result.ensureValid();
616  return result;
617 }
618 
619 /* ################## ad::physics::Speed ################ */
620 
632 inline ad::physics::Speed operator*(ad::physics::Speed const &value, ad::physics::ParametricValue const &p)
633 {
634  p.ensureValid();
635  value.ensureValid();
636  ad::physics::Speed const result(static_cast<double>(p) * static_cast<double>(value));
637  result.ensureValid();
638  return result;
639 }
640 
652 inline ad::physics::Speed operator*(ad::physics::ParametricValue const &p, ad::physics::Speed const &value)
653 {
654  return operator*(value, p);
655 }
656 
668 inline ad::physics::Speed operator/(ad::physics::Speed const &value, ad::physics::ParametricValue const &p)
669 {
670  p.ensureValidNonZero();
671  value.ensureValid();
672  ad::physics::Speed const result(static_cast<double>(value) / static_cast<double>(p));
673  result.ensureValid();
674  return result;
675 }
676 
677 /* ################## ad::physics::SpeedSquared ################ */
678 
690 inline ad::physics::SpeedSquared operator*(ad::physics::SpeedSquared const &value,
691  ad::physics::ParametricValue const &p)
692 {
693  p.ensureValid();
694  value.ensureValid();
695  ad::physics::SpeedSquared const result(static_cast<double>(p) * static_cast<double>(value));
696  result.ensureValid();
697  return result;
698 }
699 
711 inline ad::physics::SpeedSquared operator*(ad::physics::ParametricValue const &p,
712  ad::physics::SpeedSquared const &value)
713 {
714  return operator*(value, p);
715 }
716 
728 inline ad::physics::SpeedSquared operator/(ad::physics::SpeedSquared const &value,
729  ad::physics::ParametricValue const &p)
730 {
731  p.ensureValidNonZero();
732  value.ensureValid();
733  ad::physics::SpeedSquared const result(static_cast<double>(value) / static_cast<double>(p));
734  result.ensureValid();
735  return result;
736 }
737 
738 /* ################## ad::physics::Weight ################ */
739 
751 inline ad::physics::Weight operator*(ad::physics::Weight const &value, ad::physics::ParametricValue const &p)
752 {
753  p.ensureValid();
754  value.ensureValid();
755  ad::physics::Weight const result(static_cast<double>(p) * static_cast<double>(value));
756  result.ensureValid();
757  return result;
758 }
759 
771 inline ad::physics::Weight operator*(ad::physics::ParametricValue const &p, ad::physics::Weight const &value)
772 {
773  return operator*(value, p);
774 }
775 
787 inline ad::physics::Weight operator/(ad::physics::Weight const &value, ad::physics::ParametricValue const &p)
788 {
789  p.ensureValidNonZero();
790  value.ensureValid();
791  ad::physics::Weight const result(static_cast<double>(value) / static_cast<double>(p));
792  result.ensureValid();
793  return result;
794 }
operator*
ad::physics::Acceleration operator*(ad::physics::Acceleration const &value, ad::physics::ParametricValue const &p)
Arithmetic physics operation value = value * p.
Definition: ParametricOperation.hpp:30
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
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::Duration
DataType Duration.
Definition: Duration.hpp:67
ad::physics::AngularVelocity
DataType AngularVelocity.
Definition: AngularVelocity.hpp:59
ad::physics::ParametricValue::ensureValidNonZero
void ensureValidNonZero() const
ensure that the ParametricValue is valid and non zero
Definition: ParametricValue.hpp:412
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::ParametricValue const &p)
Arithmetic physics operation value = value / p.
Definition: ParametricOperation.hpp:68
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