1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.hipparchus.util;
18
19 import java.util.Arrays;
20
21 import org.hipparchus.CalculusFieldElement;
22 import org.hipparchus.Field;
23 import org.hipparchus.exception.LocalizedCoreFormats;
24 import org.hipparchus.exception.MathIllegalArgumentException;
25
26
27
28
29
30
31 public class FieldTuple<T extends CalculusFieldElement<T>> implements CalculusFieldElement<FieldTuple<T>> {
32
33
34 private final T[] values;
35
36
37 private final FieldTupleField<T> field;
38
39
40
41
42 @SafeVarargs
43 public FieldTuple(final T... x) {
44 this(new FieldTupleField<>(x[0].getField(), x.length), x.clone());
45 }
46
47
48
49
50
51 private FieldTuple(final FieldTupleField<T> field, final T[] x) {
52 this.values = x;
53 this.field = field;
54 }
55
56
57 @Override
58 public FieldTuple<T> newInstance(final double value) {
59 return field.getZero().add(value);
60 }
61
62
63
64
65 public int getDimension() {
66 return values.length;
67 }
68
69
70
71
72
73 public T getComponent(final int index) {
74 return values[index];
75 }
76
77
78
79
80 public T[] getComponents() {
81 return values.clone();
82 }
83
84
85 @Override
86 public Field<FieldTuple<T>> getField() {
87 return field;
88 }
89
90
91 @Override
92 public FieldTuple<T> add(final FieldTuple<T> a) {
93 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
94 for (int i = 0; i < values.length; ++i) {
95 result.values[i] = values[i].add(a.values[i]);
96 }
97 return result;
98 }
99
100
101 @Override
102 public FieldTuple<T> subtract(final FieldTuple<T> a) {
103 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
104 for (int i = 0; i < values.length; ++i) {
105 result.values[i] = values[i].subtract(a.values[i]);
106 }
107 return result;
108 }
109
110
111 @Override
112 public FieldTuple<T> negate() {
113 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
114 for (int i = 0; i < values.length; ++i) {
115 result.values[i] = values[i].negate();
116 }
117 return result;
118 }
119
120
121 @Override
122 public FieldTuple<T> multiply(final FieldTuple<T> a) {
123 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
124 for (int i = 0; i < values.length; ++i) {
125 result.values[i] = values[i].multiply(a.values[i]);
126 }
127 return result;
128 }
129
130
131 @Override
132 public FieldTuple<T> multiply(final int n) {
133 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
134 for (int i = 0; i < values.length; ++i) {
135 result.values[i] = values[i].multiply(n);
136 }
137 return result;
138 }
139
140
141 @Override
142 public FieldTuple<T> divide(final FieldTuple<T> a) {
143 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
144 for (int i = 0; i < values.length; ++i) {
145 result.values[i] = values[i].divide(a.values[i]);
146 }
147 return result;
148 }
149
150
151 @Override
152 public FieldTuple<T> reciprocal() {
153 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
154 for (int i = 0; i < values.length; ++i) {
155 result.values[i] = values[i].reciprocal();
156 }
157 return result;
158 }
159
160
161 @Override
162 public boolean equals(final Object obj) {
163 if (obj instanceof FieldTuple<?> ) {
164 @SuppressWarnings("unchecked")
165 final FieldTuple<T> that = (FieldTuple<T>) obj;
166 if (getDimension() == that.getDimension()) {
167 boolean equals = true;
168 for (int i = 0; i < values.length; ++i) {
169 equals &= values[i].equals(that.values[i]);
170 }
171 return equals;
172 }
173 }
174 return false;
175 }
176
177
178 @Override
179 public int hashCode() {
180 return 0x58f61de5 + Arrays.hashCode(values);
181 }
182
183
184 @Override
185 public double getReal() {
186 return values[0].getReal();
187 }
188
189
190 @Override
191 public FieldTuple<T> getAddendum() {
192 final T[] addendum = values.clone();
193 addendum[0] = addendum[0].getField().getZero();
194 for (int i = 1; i < addendum.length; ++i) {
195 addendum[i] = addendum[i].subtract(values[0]);
196 }
197 return new FieldTuple<>(field, addendum);
198 }
199
200
201 @Override
202 public FieldTuple<T> add(final double a) {
203 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
204 for (int i = 0; i < values.length; ++i) {
205 result.values[i] = values[i].add(a);
206 }
207 return result;
208 }
209
210
211 @Override
212 public FieldTuple<T> subtract(final double a) {
213 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
214 for (int i = 0; i < values.length; ++i) {
215 result.values[i] = values[i].subtract(a);
216 }
217 return result;
218 }
219
220
221 @Override
222 public FieldTuple<T> multiply(final double a) {
223 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
224 for (int i = 0; i < values.length; ++i) {
225 result.values[i] = values[i].multiply(a);
226 }
227 return result;
228 }
229
230
231 @Override
232 public FieldTuple<T> square() {
233 return multiply(this);
234 }
235
236
237 @Override
238 public FieldTuple<T> divide(final double a) {
239 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
240 for (int i = 0; i < values.length; ++i) {
241 result.values[i] = values[i].divide(a);
242 }
243 return result;
244 }
245
246
247 @Override
248 public FieldTuple<T> remainder(final double a) {
249 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
250 for (int i = 0; i < values.length; ++i) {
251 result.values[i] = values[i].remainder(a);
252 }
253 return result;
254 }
255
256
257 @Override
258 public FieldTuple<T> remainder(final FieldTuple<T> a) {
259 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
260 for (int i = 0; i < values.length; ++i) {
261 result.values[i] = values[i].remainder(a.values[i]);
262 }
263 return result;
264 }
265
266
267 @Override
268 public FieldTuple<T> abs() {
269 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
270 for (int i = 0; i < values.length; ++i) {
271 result.values[i] = values[i].abs();
272 }
273 return result;
274 }
275
276
277 @Override
278 public FieldTuple<T> ceil() {
279 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
280 for (int i = 0; i < values.length; ++i) {
281 result.values[i] = values[i].ceil();
282 }
283 return result;
284 }
285
286
287 @Override
288 public FieldTuple<T> floor() {
289 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
290 for (int i = 0; i < values.length; ++i) {
291 result.values[i] = values[i].floor();
292 }
293 return result;
294 }
295
296
297 @Override
298 public FieldTuple<T> rint() {
299 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
300 for (int i = 0; i < values.length; ++i) {
301 result.values[i] = values[i].rint();
302 }
303 return result;
304 }
305
306
307 @Override
308 public FieldTuple<T> sign() {
309 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
310 for (int i = 0; i < values.length; ++i) {
311 result.values[i] = values[i].sign();
312 }
313 return result;
314 }
315
316
317 @Override
318 public FieldTuple<T> copySign(final FieldTuple<T> sign) {
319 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
320 for (int i = 0; i < values.length; ++i) {
321 result.values[i] = values[i].copySign(sign.values[i]);
322 }
323 return result;
324 }
325
326
327 @Override
328 public FieldTuple<T> copySign(final double sign) {
329 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
330 for (int i = 0; i < values.length; ++i) {
331 result.values[i] = values[i].copySign(sign);
332 }
333 return result;
334 }
335
336
337 @Override
338 public FieldTuple<T> scalb(final int n) {
339 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
340 for (int i = 0; i < values.length; ++i) {
341 result.values[i] = values[i].scalb(n);
342 }
343 return result;
344 }
345
346
347 @Override
348 public FieldTuple<T> ulp() {
349 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
350 for (int i = 0; i < values.length; ++i) {
351 result.values[i] = values[i].ulp();
352 }
353 return result;
354 }
355
356
357 @Override
358 public FieldTuple<T> hypot(final FieldTuple<T> y) {
359 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
360 for (int i = 0; i < values.length; ++i) {
361 result.values[i] = values[i].hypot(y.values[i]);
362 }
363 return result;
364 }
365
366
367 @Override
368 public FieldTuple<T> sqrt() {
369 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
370 for (int i = 0; i < values.length; ++i) {
371 result.values[i] = values[i].sqrt();
372 }
373 return result;
374 }
375
376
377 @Override
378 public FieldTuple<T> cbrt() {
379 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
380 for (int i = 0; i < values.length; ++i) {
381 result.values[i] = values[i].cbrt();
382 }
383 return result;
384 }
385
386
387 @Override
388 public FieldTuple<T> rootN(final int n) {
389 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
390 for (int i = 0; i < values.length; ++i) {
391 result.values[i] = values[i].rootN(n);
392 }
393 return result;
394 }
395
396
397 @Override
398 public FieldTuple<T> pow(final double p) {
399 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
400 for (int i = 0; i < values.length; ++i) {
401 result.values[i] = values[i].pow(p);
402 }
403 return result;
404 }
405
406
407 @Override
408 public FieldTuple<T> pow(final int n) {
409 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
410 for (int i = 0; i < values.length; ++i) {
411 result.values[i] = values[i].pow(n);
412 }
413 return result;
414 }
415
416
417 @Override
418 public FieldTuple<T> pow(final FieldTuple<T> e) {
419 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
420 for (int i = 0; i < values.length; ++i) {
421 result.values[i] = values[i].pow(e.values[i]);
422 }
423 return result;
424 }
425
426
427 @Override
428 public FieldTuple<T> exp() {
429 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
430 for (int i = 0; i < values.length; ++i) {
431 result.values[i] = values[i].exp();
432 }
433 return result;
434 }
435
436
437 @Override
438 public FieldTuple<T> expm1() {
439 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
440 for (int i = 0; i < values.length; ++i) {
441 result.values[i] = values[i].expm1();
442 }
443 return result;
444 }
445
446
447 @Override
448 public FieldTuple<T> log() {
449 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
450 for (int i = 0; i < values.length; ++i) {
451 result.values[i] = values[i].log();
452 }
453 return result;
454 }
455
456
457 @Override
458 public FieldTuple<T> log1p() {
459 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
460 for (int i = 0; i < values.length; ++i) {
461 result.values[i] = values[i].log1p();
462 }
463 return result;
464 }
465
466
467 @Override
468 public FieldTuple<T> log10() {
469 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
470 for (int i = 0; i < values.length; ++i) {
471 result.values[i] = values[i].log10();
472 }
473 return result;
474 }
475
476
477 @Override
478 public FieldTuple<T> cos() {
479 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
480 for (int i = 0; i < values.length; ++i) {
481 result.values[i] = values[i].cos();
482 }
483 return result;
484 }
485
486
487 @Override
488 public FieldTuple<T> sin() {
489 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
490 for (int i = 0; i < values.length; ++i) {
491 result.values[i] = values[i].sin();
492 }
493 return result;
494 }
495
496
497 @Override
498 public FieldSinCos<FieldTuple<T>> sinCos() {
499 final FieldTuple<T> sin = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
500 final FieldTuple<T> cos = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
501 for (int i = 0; i < values.length; ++i) {
502 final FieldSinCos<T> sc = FastMath.sinCos(values[i]);
503 sin.values[i] = sc.sin();
504 cos.values[i] = sc.cos();
505 }
506 return new FieldSinCos<>(sin, cos);
507 }
508
509
510 @Override
511 public FieldTuple<T> tan() {
512 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
513 for (int i = 0; i < values.length; ++i) {
514 result.values[i] = values[i].tan();
515 }
516 return result;
517 }
518
519
520 @Override
521 public FieldTuple<T> acos() {
522 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
523 for (int i = 0; i < values.length; ++i) {
524 result.values[i] = values[i].acos();
525 }
526 return result;
527 }
528
529
530 @Override
531 public FieldTuple<T> asin() {
532 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
533 for (int i = 0; i < values.length; ++i) {
534 result.values[i] = values[i].asin();
535 }
536 return result;
537 }
538
539
540 @Override
541 public FieldTuple<T> atan() {
542 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
543 for (int i = 0; i < values.length; ++i) {
544 result.values[i] = values[i].atan();
545 }
546 return result;
547 }
548
549
550 @Override
551 public FieldTuple<T> atan2(final FieldTuple<T> x) {
552 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
553 for (int i = 0; i < values.length; ++i) {
554 result.values[i] = values[i].atan2(x.values[i]);
555 }
556 return result;
557 }
558
559
560 @Override
561 public FieldTuple<T> cosh() {
562 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
563 for (int i = 0; i < values.length; ++i) {
564 result.values[i] = values[i].cosh();
565 }
566 return result;
567 }
568
569
570 @Override
571 public FieldTuple<T> sinh() {
572 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
573 for (int i = 0; i < values.length; ++i) {
574 result.values[i] = values[i].sinh();
575 }
576 return result;
577 }
578
579
580 @Override
581 public FieldSinhCosh<FieldTuple<T>> sinhCosh() {
582 final FieldTuple<T> sinh = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
583 final FieldTuple<T> cosh = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
584 for (int i = 0; i < values.length; ++i) {
585 final FieldSinhCosh<T> sc = FastMath.sinhCosh(values[i]);
586 sinh.values[i] = sc.sinh();
587 cosh.values[i] = sc.cosh();
588 }
589 return new FieldSinhCosh<>(sinh, cosh);
590 }
591
592
593 @Override
594 public FieldTuple<T> tanh() {
595 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
596 for (int i = 0; i < values.length; ++i) {
597 result.values[i] = values[i].tanh();
598 }
599 return result;
600 }
601
602
603 @Override
604 public FieldTuple<T> acosh() {
605 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
606 for (int i = 0; i < values.length; ++i) {
607 result.values[i] = values[i].acosh();
608 }
609 return result;
610 }
611
612
613 @Override
614 public FieldTuple<T> asinh() {
615 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
616 for (int i = 0; i < values.length; ++i) {
617 result.values[i] = values[i].asinh();
618 }
619 return result;
620 }
621
622
623 @Override
624 public FieldTuple<T> atanh() {
625 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
626 for (int i = 0; i < values.length; ++i) {
627 result.values[i] = values[i].atanh();
628 }
629 return result;
630 }
631
632
633 @Override
634 public FieldTuple<T> toDegrees() {
635 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
636 for (int i = 0; i < values.length; ++i) {
637 result.values[i] = values[i].toDegrees();
638 }
639 return result;
640 }
641
642
643 @Override
644 public FieldTuple<T> toRadians() {
645 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
646 for (int i = 0; i < values.length; ++i) {
647 result.values[i] = values[i].toRadians();
648 }
649 return result;
650 }
651
652
653 @Override
654 public FieldTuple<T> linearCombination(final FieldTuple<T>[] a, final FieldTuple<T>[] b)
655 throws MathIllegalArgumentException {
656 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
657 MathUtils.checkDimension(a.length, b.length);
658 final T[] aT = MathArrays.buildArray(values[0].getField(), a.length);
659 final T[] bT = MathArrays.buildArray(values[0].getField(), b.length);
660 for (int i = 0; i < values.length; ++i) {
661 for (int j = 0; j < a.length; ++j) {
662 aT[j] = a[j].values[i];
663 bT[j] = b[j].values[i];
664 }
665 result.values[i] = aT[0].linearCombination(aT, bT);
666 }
667 return result;
668 }
669
670
671 @Override
672 public FieldTuple<T> linearCombination(final double[] a, final FieldTuple<T>[] b)
673 throws MathIllegalArgumentException {
674 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
675 MathUtils.checkDimension(a.length, b.length);
676 final T[] bT = MathArrays.buildArray(values[0].getField(), b.length);
677 for (int i = 0; i < values.length; ++i) {
678 for (int j = 0; j < a.length; ++j) {
679 bT[j] = b[j].values[i];
680 }
681 result.values[i] = bT[0].linearCombination(a, bT);
682 }
683 return result;
684 }
685
686
687 @Override
688 public FieldTuple<T> linearCombination(final FieldTuple<T> a1, final FieldTuple<T> b1,
689 final FieldTuple<T> a2, final FieldTuple<T> b2) {
690 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
691 for (int i = 0; i < values.length; ++i) {
692 result.values[i] = a1.values[0].linearCombination(a1.values[i], b1.values[i],
693 a2.values[i], b2.values[i]);
694 }
695 return result;
696 }
697
698
699 @Override
700 public FieldTuple<T> linearCombination(final double a1, final FieldTuple<T> b1,
701 final double a2, final FieldTuple<T> b2) {
702 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
703 for (int i = 0; i < values.length; ++i) {
704 result.values[i] = b1.values[0].linearCombination(a1, b1.values[i],
705 a2, b2.values[i]);
706 }
707 return result;
708 }
709
710
711 @Override
712 public FieldTuple<T> linearCombination(final FieldTuple<T> a1, final FieldTuple<T> b1,
713 final FieldTuple<T> a2, final FieldTuple<T> b2,
714 final FieldTuple<T> a3, final FieldTuple<T> b3) {
715 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
716 for (int i = 0; i < values.length; ++i) {
717 result.values[i] = a1.values[0].linearCombination(a1.values[i], b1.values[i],
718 a2.values[i], b2.values[i],
719 a3.values[i], b3.values[i]);
720 }
721 return result;
722 }
723
724
725 @Override
726 public FieldTuple<T> linearCombination(final double a1, final FieldTuple<T> b1,
727 final double a2, final FieldTuple<T> b2,
728 final double a3, final FieldTuple<T> b3) {
729 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
730 for (int i = 0; i < values.length; ++i) {
731 result.values[i] = b1.values[0].linearCombination(a1, b1.values[i],
732 a2, b2.values[i],
733 a3, b3.values[i]);
734 }
735 return result;
736 }
737
738
739 @Override
740 public FieldTuple<T> linearCombination(final FieldTuple<T> a1, final FieldTuple<T> b1,
741 final FieldTuple<T> a2, final FieldTuple<T> b2,
742 final FieldTuple<T> a3, final FieldTuple<T> b3,
743 final FieldTuple<T> a4, final FieldTuple<T> b4) {
744 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
745 for (int i = 0; i < values.length; ++i) {
746 result.values[i] = a1.values[0].linearCombination(a1.values[i], b1.values[i],
747 a2.values[i], b2.values[i],
748 a3.values[i], b3.values[i],
749 a4.values[i], b4.values[i]);
750 }
751 return result;
752 }
753
754
755 @Override
756 public FieldTuple<T> linearCombination(final double a1, final FieldTuple<T> b1,
757 final double a2, final FieldTuple<T> b2,
758 final double a3, final FieldTuple<T> b3,
759 final double a4, final FieldTuple<T> b4) {
760 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
761 for (int i = 0; i < values.length; ++i) {
762 result.values[i] = b1.values[0].linearCombination(a1, b1.values[i],
763 a2, b2.values[i],
764 a3, b3.values[i],
765 a4, b4.values[i]);
766 }
767 return result;
768 }
769
770
771 @Override
772 public double norm() {
773 double sum = 0;
774 for (final T value: values) {
775 sum += value.norm();
776 }
777 return sum;
778 }
779
780
781 @Override
782 public FieldTuple<T> getPi() {
783 final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length));
784 Arrays.fill(result.values, values[0].getPi());
785 return result;
786 }
787
788
789 @Override
790 public boolean isSmall(final FieldTuple<T> base, final double relativeThreshold) {
791 if (values.length != base.values.length) {
792 throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
793 values.length, base.values.length);
794 }
795 boolean ok = true;
796 for (int i = 0; i < values.length && ok; ++i) {
797 ok = values[i].isSmall(base.values[i], relativeThreshold);
798 }
799 return ok;
800 }
801
802
803
804
805 private static class FieldTupleField<T extends CalculusFieldElement<T>> implements Field<FieldTuple<T>> {
806
807
808 private final FieldTuple<T> zero;
809
810
811 private final FieldTuple<T> one;
812
813
814
815
816
817 FieldTupleField(final Field<T> field, final int dimension) {
818 final T[] zeroData = MathArrays.buildArray(field, dimension);
819 Arrays.fill(zeroData, field.getZero());
820 final T[] oneData = MathArrays.buildArray(field, dimension);
821 Arrays.fill(oneData, field.getOne());
822 this.zero = new FieldTuple<>(this, zeroData);
823 this.one = new FieldTuple<>(this, oneData);
824 }
825
826
827 @Override
828 public FieldTuple<T> getZero() {
829 return zero;
830 }
831
832
833 @Override
834 public FieldTuple<T> getOne() {
835 return one;
836 }
837
838
839 @SuppressWarnings("unchecked")
840 @Override
841 public Class<FieldTuple<T>> getRuntimeClass() {
842 return (Class<FieldTuple<T>>) zero.getClass();
843 }
844
845
846 @Override
847 public boolean equals(final Object other) {
848 if (other instanceof FieldTupleField) {
849 @SuppressWarnings("unchecked")
850 final FieldTupleField<T> that = (FieldTupleField<T>) other;
851 return zero.getDimension() == that.zero.getDimension();
852 } else {
853 return false;
854 }
855 }
856
857
858 @Override
859 public int hashCode() {
860 return 0xb4a533e1 ^ zero.getDimension();
861 }
862
863 }
864
865 }