1 /*
2 * Copyright (C) 2020 Alberto Irurueta Carro (alberto@irurueta.com)
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 package com.irurueta.navigation.inertial.calibration;
17
18 import com.irurueta.navigation.frames.ECEFFrame;
19 import com.irurueta.navigation.frames.NEDFrame;
20 import com.irurueta.navigation.inertial.BodyMagneticFluxDensity;
21
22 import java.io.Serial;
23 import java.util.Date;
24 import java.util.GregorianCalendar;
25 import java.util.Objects;
26
27 /**
28 * Extension of FrameBodyMagneticFluxDensity containing standard deviations of
29 * measured magnetic flux densities besides their corresponding frame (position
30 * and orientation) and timestamp where measurement was made.
31 */
32 public class StandardDeviationFrameBodyMagneticFluxDensity extends FrameBodyMagneticFluxDensity {
33
34 /**
35 * Serialization version. This is used to ensure compatibility of deserialization of permanently stored serialized
36 * instances.
37 */
38 @Serial
39 private static final long serialVersionUID = 0L;
40
41 /**
42 * Standard deviation of measured magnetic flux density expressed in Teslas
43 * (T).
44 */
45 private double magneticFluxDensityStandardDeviation;
46
47 /**
48 * Constructor.
49 */
50 public StandardDeviationFrameBodyMagneticFluxDensity() {
51 }
52
53 /**
54 * Constructor.
55 *
56 * @param magneticFluxDensity current body magnetic flux density.
57 */
58 public StandardDeviationFrameBodyMagneticFluxDensity(final BodyMagneticFluxDensity magneticFluxDensity) {
59 super(magneticFluxDensity);
60 }
61
62 /**
63 * Constructor.
64 *
65 * @param frame current ECEF frame associated to measurement.
66 */
67 public StandardDeviationFrameBodyMagneticFluxDensity(final ECEFFrame frame) {
68 super(frame);
69 }
70
71 /**
72 * Constructor.
73 *
74 * @param frame current NED frame associated to measurement. Internally it
75 * will be converted to its corresponding ECEF frame.
76 */
77 public StandardDeviationFrameBodyMagneticFluxDensity(final NEDFrame frame) {
78 super(frame);
79 }
80
81 /**
82 * Constructor.
83 *
84 * @param magneticFluxDensity current body magnetic flux density.
85 * @param frame current ECEF frame associated to measurement.
86 */
87 public StandardDeviationFrameBodyMagneticFluxDensity(
88 final BodyMagneticFluxDensity magneticFluxDensity, final ECEFFrame frame) {
89 super(magneticFluxDensity, frame);
90 }
91
92 /**
93 * Constructor.
94 *
95 * @param magneticFluxDensity current body magnetic flux density.
96 * @param frame current NED frame associated to measurement.
97 * Internally it will be converted to its
98 * corresponding ECEF frame.
99 */
100 public StandardDeviationFrameBodyMagneticFluxDensity(
101 final BodyMagneticFluxDensity magneticFluxDensity, final NEDFrame frame) {
102 super(magneticFluxDensity, frame);
103 }
104
105 /**
106 * Constructor.
107 *
108 * @param year time expressed as decimal year.
109 */
110 public StandardDeviationFrameBodyMagneticFluxDensity(final double year) {
111 super(year);
112 }
113
114 /**
115 * Constructor.
116 *
117 * @param magneticFluxDensity current body magnetic flux density.
118 * @param year time expressed as decimal year.
119 */
120 public StandardDeviationFrameBodyMagneticFluxDensity(
121 final BodyMagneticFluxDensity magneticFluxDensity, final double year) {
122 super(magneticFluxDensity, year);
123 }
124
125 /**
126 * Constructor.
127 *
128 * @param frame current ECEF frame associated to measurement.
129 * @param year time expressed as decimal year.
130 */
131 public StandardDeviationFrameBodyMagneticFluxDensity(final ECEFFrame frame, final double year) {
132 super(frame, year);
133 }
134
135 /**
136 * Constructor.
137 *
138 * @param frame current NED frame associated to measurement. Internally it
139 * will be converted to its corresponding ECEF frame.
140 * @param year time expressed as decimal year.
141 */
142 public StandardDeviationFrameBodyMagneticFluxDensity(final NEDFrame frame, final double year) {
143 super(frame, year);
144 }
145
146 /**
147 * Constructor.
148 *
149 * @param magneticFluxDensity current body magnetic flux density.
150 * @param frame current ECEF frame associated to measurement.
151 * @param year time expressed as decimal year.
152 */
153 public StandardDeviationFrameBodyMagneticFluxDensity(
154 final BodyMagneticFluxDensity magneticFluxDensity, final ECEFFrame frame, final double year) {
155 super(magneticFluxDensity, frame, year);
156 }
157
158 /**
159 * Constructor.
160 *
161 * @param magneticFluxDensity current body magnetic flux density.
162 * @param frame current NED frame associated to measurement.
163 * Internally it will be converted to its
164 * corresponding ECEF frame.
165 * @param year time expressed as decimal year.
166 */
167 public StandardDeviationFrameBodyMagneticFluxDensity(
168 final BodyMagneticFluxDensity magneticFluxDensity, final NEDFrame frame, final double year) {
169 super(magneticFluxDensity, frame, year);
170 }
171
172 /**
173 * Constructor.
174 *
175 * @param time a timestamp.
176 */
177 public StandardDeviationFrameBodyMagneticFluxDensity(final Date time) {
178 super(time);
179 }
180
181 /**
182 * Constructor.
183 *
184 * @param magneticFluxDensity current body magnetic flux density.
185 * @param time a timestamp.
186 */
187 public StandardDeviationFrameBodyMagneticFluxDensity(
188 final BodyMagneticFluxDensity magneticFluxDensity, final Date time) {
189 super(magneticFluxDensity, time);
190 }
191
192 /**
193 * Constructor.
194 *
195 * @param frame current ECEF frame associated to measurement.
196 * @param time a timestamp.
197 */
198 public StandardDeviationFrameBodyMagneticFluxDensity(final ECEFFrame frame, final Date time) {
199 super(frame, time);
200 }
201
202 /**
203 * Constructor.
204 *
205 * @param frame current NED frame associated to measurement. Internally it
206 * will be converted to its corresponding ECEF frame.
207 * @param time a timestamp.
208 */
209 public StandardDeviationFrameBodyMagneticFluxDensity(final NEDFrame frame, final Date time) {
210 super(frame, time);
211 }
212
213 /**
214 * Constructor.
215 *
216 * @param magneticFluxDensity current body magnetic flux density.
217 * @param frame current ECEF frame associated to measurement.
218 * @param time a timestamp.
219 */
220 public StandardDeviationFrameBodyMagneticFluxDensity(
221 final BodyMagneticFluxDensity magneticFluxDensity, final ECEFFrame frame, final Date time) {
222 super(magneticFluxDensity, frame, time);
223 }
224
225 /**
226 * Constructor.
227 *
228 * @param magneticFluxDensity current body magnetic flux density.
229 * @param frame current NED frame associated to measurement.
230 * Internally it will be converted to its
231 * corresponding ECEF frame.
232 * @param time a timestamp.
233 */
234 public StandardDeviationFrameBodyMagneticFluxDensity(
235 final BodyMagneticFluxDensity magneticFluxDensity, final NEDFrame frame, final Date time) {
236 super(magneticFluxDensity, frame, time);
237 }
238
239 /**
240 * Constructor.
241 *
242 * @param calendar calendar containing a timestamp.
243 */
244 public StandardDeviationFrameBodyMagneticFluxDensity(final GregorianCalendar calendar) {
245 super(calendar);
246 }
247
248 /**
249 * Constructor.
250 *
251 * @param magneticFluxDensity current body magnetic flux density.
252 * @param calendar calendar containing a timestamp.
253 */
254 public StandardDeviationFrameBodyMagneticFluxDensity(
255 final BodyMagneticFluxDensity magneticFluxDensity, final GregorianCalendar calendar) {
256 super(magneticFluxDensity, calendar);
257 }
258
259 /**
260 * Constructor.
261 *
262 * @param frame current ECEF frame associated to measurement.
263 * @param calendar calendar containing a timestamp.
264 */
265 public StandardDeviationFrameBodyMagneticFluxDensity(final ECEFFrame frame, final GregorianCalendar calendar) {
266 super(frame, calendar);
267 }
268
269 /**
270 * Constructor.
271 *
272 * @param frame current NED frame associated to measurement. Internally it
273 * will be converted to its corresponding ECEF frame.
274 * @param calendar calendar containing a timestamp.
275 */
276 public StandardDeviationFrameBodyMagneticFluxDensity(final NEDFrame frame, final GregorianCalendar calendar) {
277 super(frame, calendar);
278 }
279
280 /**
281 * Constructor.
282 *
283 * @param magneticFluxDensity current body magnetic flux density.
284 * @param frame current ECEF frame associated to measurement.
285 * @param calendar calendar containing a timestamp.
286 */
287 public StandardDeviationFrameBodyMagneticFluxDensity(
288 final BodyMagneticFluxDensity magneticFluxDensity, final ECEFFrame frame,
289 final GregorianCalendar calendar) {
290 super(magneticFluxDensity, frame, calendar);
291 }
292
293 /**
294 * Constructor.
295 *
296 * @param magneticFluxDensity current body magnetic flux density.
297 * @param frame current NED frame associated to measurement.
298 * Internally it will be converted to its
299 * corresponding ECEF frame.
300 * @param calendar calendar containing a timestamp.
301 */
302 public StandardDeviationFrameBodyMagneticFluxDensity(
303 final BodyMagneticFluxDensity magneticFluxDensity, final NEDFrame frame, final GregorianCalendar calendar) {
304 super(magneticFluxDensity, frame, calendar);
305 }
306
307 /**
308 * Constructor.
309 *
310 * @param year time expressed as decimal
311 * year.
312 * @param magneticFluxDensityStandardDeviation standard deviation of
313 * measured magnetic flux
314 * density.
315 * @throws IllegalArgumentException if provided standard deviation is
316 * negative.
317 */
318 public StandardDeviationFrameBodyMagneticFluxDensity(
319 final double year, final double magneticFluxDensityStandardDeviation) {
320 super(year);
321 setMagneticFluxDensityStandardDeviation(
322 magneticFluxDensityStandardDeviation);
323 }
324
325 /**
326 * Constructor.
327 *
328 * @param magneticFluxDensity current body magnetic flux
329 * density.
330 * @param year time expressed as decimal
331 * year.
332 * @param magneticFluxDensityStandardDeviation standard deviation of
333 * measured magnetic flux
334 * density.
335 * @throws IllegalArgumentException if provided standard deviation is
336 * negative.
337 */
338 public StandardDeviationFrameBodyMagneticFluxDensity(
339 final BodyMagneticFluxDensity magneticFluxDensity, final double year,
340 final double magneticFluxDensityStandardDeviation) {
341 super(magneticFluxDensity, year);
342 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
343 }
344
345 /**
346 * Constructor.
347 *
348 * @param frame current ECEF frame
349 * associated to measurement.
350 * @param year time expressed as decimal
351 * year.
352 * @param magneticFluxDensityStandardDeviation standard deviation of
353 * measured magnetic flux
354 * density.
355 * @throws IllegalArgumentException if provided standard deviation is
356 * negative.
357 */
358 public StandardDeviationFrameBodyMagneticFluxDensity(
359 final ECEFFrame frame, final double year, final double magneticFluxDensityStandardDeviation) {
360 super(frame, year);
361 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
362 }
363
364 /**
365 * Constructor.
366 *
367 * @param frame current NED frame
368 * associated to measurement.
369 * Internally it will be
370 * converted to its
371 * corresponding ECEF frame.
372 * @param year time expressed as decimal
373 * year.
374 * @param magneticFluxDensityStandardDeviation standard deviation of
375 * measured magnetic flux
376 * density.
377 * @throws IllegalArgumentException if provided standard deviation is
378 * negative.
379 */
380 public StandardDeviationFrameBodyMagneticFluxDensity(
381 final NEDFrame frame, final double year, final double magneticFluxDensityStandardDeviation) {
382 super(frame, year);
383 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
384 }
385
386 /**
387 * Constructor.
388 *
389 * @param magneticFluxDensity current body magnetic flux
390 * density.
391 * @param frame current ECEF frame
392 * associated to measurement.
393 * @param year time expressed as decimal
394 * year.
395 * @param magneticFluxDensityStandardDeviation standard deviation of
396 * measured magnetic flux
397 * density.
398 * @throws IllegalArgumentException if provided standard deviation is
399 * negative.
400 */
401 public StandardDeviationFrameBodyMagneticFluxDensity(
402 final BodyMagneticFluxDensity magneticFluxDensity, final ECEFFrame frame, final double year,
403 final double magneticFluxDensityStandardDeviation) {
404 super(magneticFluxDensity, frame, year);
405 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
406 }
407
408 /**
409 * Constructor.
410 *
411 * @param magneticFluxDensity current body magnetic flux
412 * density.
413 * @param frame current NED frame
414 * associated to measurement.
415 * Internally it will be
416 * converted to its
417 * corresponding ECEF frame.
418 * @param year time expressed as decimal year.
419 * @param magneticFluxDensityStandardDeviation standard deviation of
420 * measured magnetic flux
421 * density.
422 * @throws IllegalArgumentException if provided standard deviation is
423 * negative.
424 */
425 public StandardDeviationFrameBodyMagneticFluxDensity(
426 final BodyMagneticFluxDensity magneticFluxDensity, final NEDFrame frame, final double year,
427 final double magneticFluxDensityStandardDeviation) {
428 super(magneticFluxDensity, frame, year);
429 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
430 }
431
432 /**
433 * Constructor.
434 *
435 * @param time a timestamp.
436 * @param magneticFluxDensityStandardDeviation standard deviation of
437 * measured magnetic flux
438 * density.
439 * @throws IllegalArgumentException if provided standard deviation is
440 * negative.
441 */
442 public StandardDeviationFrameBodyMagneticFluxDensity(
443 final Date time, final double magneticFluxDensityStandardDeviation) {
444 super(time);
445 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
446 }
447
448 /**
449 * Constructor.
450 *
451 * @param magneticFluxDensity current body magnetic flux density.
452 * @param time a timestamp.
453 * @param magneticFluxDensityStandardDeviation standard deviation of
454 * measured magnetic flux
455 * density.
456 * @throws IllegalArgumentException if provided standard deviation is
457 * negative.
458 */
459 public StandardDeviationFrameBodyMagneticFluxDensity(
460 final BodyMagneticFluxDensity magneticFluxDensity, final Date time,
461 final double magneticFluxDensityStandardDeviation) {
462 super(magneticFluxDensity, time);
463 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
464 }
465
466 /**
467 * Constructor.
468 *
469 * @param frame current ECEF frame
470 * associated to measurement.
471 * @param time a timestamp.
472 * @param magneticFluxDensityStandardDeviation standard deviation of
473 * measured magnetic flux
474 * density.
475 * @throws IllegalArgumentException if provided standard deviation is
476 * negative.
477 */
478 public StandardDeviationFrameBodyMagneticFluxDensity(
479 final ECEFFrame frame, final Date time, final double magneticFluxDensityStandardDeviation) {
480 super(frame, time);
481 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
482 }
483
484 /**
485 * Constructor.
486 *
487 * @param frame current NED frame associated
488 * to measurement. Internally
489 * it will be converted to its
490 * corresponding ECEF frame.
491 * @param time a timestamp.
492 * @param magneticFluxDensityStandardDeviation standard deviation of
493 * measured magnetic flux
494 * density.
495 * @throws IllegalArgumentException if provided standard deviation is
496 * negative.
497 */
498 public StandardDeviationFrameBodyMagneticFluxDensity(
499 final NEDFrame frame, final Date time, final double magneticFluxDensityStandardDeviation) {
500 super(frame, time);
501 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
502 }
503
504 /**
505 * Constructor.
506 *
507 * @param magneticFluxDensity current body magnetic flux
508 * density.
509 * @param frame current ECEF frame
510 * associated to measurement.
511 * @param time a timestamp.
512 * @param magneticFluxDensityStandardDeviation standard deviation of
513 * measured magnetic flux
514 * density.
515 * @throws IllegalArgumentException if provided standard deviation is
516 * negative.
517 */
518 public StandardDeviationFrameBodyMagneticFluxDensity(
519 final BodyMagneticFluxDensity magneticFluxDensity, final ECEFFrame frame, final Date time,
520 final double magneticFluxDensityStandardDeviation) {
521 super(magneticFluxDensity, frame, time);
522 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
523 }
524
525 /**
526 * Constructor.
527 *
528 * @param magneticFluxDensity current body magnetic flux
529 * density.
530 * @param frame current NED frame
531 * associated to measurement.
532 * Internally it will be
533 * converted to its
534 * corresponding ECEF frame.
535 * @param time a timestamp.
536 * @param magneticFluxDensityStandardDeviation standard deviation of
537 * measured magnetic flux
538 * density.
539 * @throws IllegalArgumentException if provided standard deviation is
540 * negative.
541 */
542 public StandardDeviationFrameBodyMagneticFluxDensity(
543 final BodyMagneticFluxDensity magneticFluxDensity, final NEDFrame frame, final Date time,
544 final double magneticFluxDensityStandardDeviation) {
545 super(magneticFluxDensity, frame, time);
546 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
547 }
548
549 /**
550 * Constructor.
551 *
552 * @param calendar calendar containing a
553 * timestamp.
554 * @param magneticFluxDensityStandardDeviation standard deviation of
555 * measured magnetic flux
556 * density.
557 * @throws IllegalArgumentException if provided standard deviation is
558 * negative.
559 */
560 public StandardDeviationFrameBodyMagneticFluxDensity(
561 final GregorianCalendar calendar, final double magneticFluxDensityStandardDeviation) {
562 super(calendar);
563 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
564 }
565
566 /**
567 * Constructor.
568 *
569 * @param magneticFluxDensity current body magnetic flux
570 * density.
571 * @param calendar calendar containing a
572 * timestamp.
573 * @param magneticFluxDensityStandardDeviation standard deviation of
574 * measured magnetic flux
575 * density.
576 * @throws IllegalArgumentException if provided standard deviation is
577 * negative.
578 */
579 public StandardDeviationFrameBodyMagneticFluxDensity(
580 final BodyMagneticFluxDensity magneticFluxDensity, final GregorianCalendar calendar,
581 final double magneticFluxDensityStandardDeviation) {
582 super(magneticFluxDensity, calendar);
583 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
584 }
585
586 /**
587 * Constructor.
588 *
589 * @param frame current ECEF frame
590 * associated to measurement.
591 * @param calendar calendar containing a
592 * timestamp.
593 * @param magneticFluxDensityStandardDeviation standard deviation of
594 * measured magnetic flux
595 * density.
596 * @throws IllegalArgumentException if provided standard deviation is
597 * negative.
598 */
599 public StandardDeviationFrameBodyMagneticFluxDensity(
600 final ECEFFrame frame, final GregorianCalendar calendar,
601 final double magneticFluxDensityStandardDeviation) {
602 super(frame, calendar);
603 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
604 }
605
606 /**
607 * Constructor.
608 *
609 * @param frame current NED frame
610 * associated to measurement.
611 * Internally it will be
612 * converted to its
613 * corresponding ECEF frame.
614 * @param calendar calendar containing a
615 * timestamp.
616 * @param magneticFluxDensityStandardDeviation standard deviation of
617 * measured magnetic flux
618 * density.
619 * @throws IllegalArgumentException if provided standard deviation is
620 * negative.
621 */
622 public StandardDeviationFrameBodyMagneticFluxDensity(
623 final NEDFrame frame, final GregorianCalendar calendar, final double magneticFluxDensityStandardDeviation) {
624 super(frame, calendar);
625 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
626 }
627
628 /**
629 * Constructor.
630 *
631 * @param magneticFluxDensity current body magnetic flux
632 * density.
633 * @param frame current ECEF frame
634 * associated to measurement.
635 * @param calendar calendar containing a
636 * timestamp.
637 * @param magneticFluxDensityStandardDeviation standard deviation of
638 * measured magnetic flux
639 * density.
640 * @throws IllegalArgumentException if provided standard deviation is
641 * negative.
642 */
643 public StandardDeviationFrameBodyMagneticFluxDensity(
644 final BodyMagneticFluxDensity magneticFluxDensity, final ECEFFrame frame, final GregorianCalendar calendar,
645 final double magneticFluxDensityStandardDeviation) {
646 super(magneticFluxDensity, frame, calendar);
647 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
648 }
649
650 /**
651 * Constructor.
652 *
653 * @param magneticFluxDensity current body magnetic flux
654 * density.
655 * @param frame current NED frame
656 * associated to measurement.
657 * Internally it will be
658 * converted to its
659 * corresponding ECEF frame.
660 * @param calendar calendar containing a
661 * timestamp.
662 * @param magneticFluxDensityStandardDeviation standard deviation of
663 * measured magnetic flux
664 * density.
665 * @throws IllegalArgumentException if provided standard deviation is
666 * negative.
667 */
668 public StandardDeviationFrameBodyMagneticFluxDensity(
669 final BodyMagneticFluxDensity magneticFluxDensity, final NEDFrame frame,
670 final GregorianCalendar calendar, final double magneticFluxDensityStandardDeviation) {
671 super(magneticFluxDensity, frame, calendar);
672 setMagneticFluxDensityStandardDeviation(magneticFluxDensityStandardDeviation);
673 }
674
675 /**
676 * Constructor.
677 *
678 * @param input instance to copy data from.
679 */
680 public StandardDeviationFrameBodyMagneticFluxDensity(final StandardDeviationFrameBodyMagneticFluxDensity input) {
681 copyFrom(input);
682 }
683
684 /**
685 * Gets standard deviation of measured magnetic flux density expressed in
686 * Teslas (T).
687 *
688 * @return standard deviation of measured magnetic flux density.
689 */
690 public double getMagneticFluxDensityStandardDeviation() {
691 return magneticFluxDensityStandardDeviation;
692 }
693
694 /**
695 * Sets standard deviation of measured magnetic flux density expressed in
696 * Teslas (T).
697 *
698 * @param magneticFluxDensityStandardDeviation standard deviation of
699 * measured magnetic flux
700 * density.
701 * @throws IllegalArgumentException if provided value is negative.
702 */
703 public void setMagneticFluxDensityStandardDeviation(final double magneticFluxDensityStandardDeviation) {
704 if (magneticFluxDensityStandardDeviation < 0.0) {
705 throw new IllegalArgumentException();
706 }
707
708 this.magneticFluxDensityStandardDeviation = magneticFluxDensityStandardDeviation;
709 }
710
711 /**
712 * Copies data of provided instance into this instance.
713 *
714 * @param input instance to copy data from.
715 */
716 public void copyFrom(final StandardDeviationFrameBodyMagneticFluxDensity input) {
717 super.copyFrom(input);
718
719 magneticFluxDensityStandardDeviation = input.magneticFluxDensityStandardDeviation;
720 }
721
722 /**
723 * Copies this instance data into provided instance.
724 *
725 * @param output destination instance where data will be copied to.
726 */
727 public void copyTo(final StandardDeviationFrameBodyMagneticFluxDensity output) {
728 super.copyTo(output);
729
730 output.magneticFluxDensityStandardDeviation = magneticFluxDensityStandardDeviation;
731 }
732
733 /**
734 * Computes and returns hash code for this instance. Hash codes are almost unique
735 * values that are useful for fast classification and storage of objects in collections.
736 *
737 * @return Hash code.
738 */
739 @Override
740 public int hashCode() {
741 return Objects.hash(super.hashCode(), magneticFluxDensityStandardDeviation);
742 }
743
744 /**
745 * Checks if provided instance has exactly the same contents as this instance.
746 *
747 * @param other instance to be compared.
748 * @return true if both instances are considered to be equal, false otherwise.
749 */
750 public boolean equals(final StandardDeviationFrameBodyMagneticFluxDensity other) {
751 return equals(other, 0.0);
752 }
753
754 /**
755 * Checks if provided instance has contents similar to this instance up to provided
756 * threshold value.
757 *
758 * @param other instance to be compared.
759 * @param threshold maximum allowed difference between values.
760 * @return true if both instances are considered to be equal (up to provided
761 * threshold), false otherwise.
762 */
763 public boolean equals(final StandardDeviationFrameBodyMagneticFluxDensity other, final double threshold) {
764 return super.equals(other, threshold)
765 && Math.abs(magneticFluxDensityStandardDeviation
766 - other.magneticFluxDensityStandardDeviation) <= threshold;
767 }
768
769 /**
770 * Checks if provided instance has contents similar to this instance up to provided
771 * threshold value.
772 *
773 * @param other instance to be compared.
774 * @param threshold maximum allowed difference between magnetic flux density and
775 * frame values.
776 * @return true if both instances are considered to be equal (up to provided
777 * threshold), false otherwise.
778 */
779 @Override
780 public boolean equals(final FrameBodyMagneticFluxDensity other, final double threshold) {
781 if (this == other) {
782 return true;
783 }
784 if (other == null || getClass() != other.getClass()) {
785 return false;
786 }
787 return super.equals(other, threshold);
788 }
789
790 /**
791 * Checks if provided object is a
792 * StandardDeviationFrameBodyMagneticFluxDensity instance
793 * having exactly the same contents as this instance.
794 *
795 * @param obj object to be compared.
796 * @return true if both objects are considered to be equal, false otherwise.
797 */
798 @Override
799 public boolean equals(final Object obj) {
800 if (this == obj) {
801 return true;
802 }
803 if (obj == null || getClass() != obj.getClass()) {
804 return false;
805 }
806 final var other = (StandardDeviationFrameBodyMagneticFluxDensity) obj;
807 return equals(other);
808 }
809
810 /**
811 * Makes a copy of this instance.
812 *
813 * @return a copy of this instance.
814 * @throws CloneNotSupportedException if clone fails for some reason.
815 */
816 @Override
817 protected Object clone() throws CloneNotSupportedException {
818 final var result = (StandardDeviationFrameBodyMagneticFluxDensity) super.clone();
819 copyTo(result);
820 return result;
821 }
822 }