View Javadoc
1   /*
2    * Licensed to the Hipparchus project under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The Hipparchus project licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
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   * This class allows to perform the same computation of all components of a Tuple at once.
28   * @param <T> the type of the field elements
29   * @since 1.2
30   */
31  public class FieldTuple<T extends CalculusFieldElement<T>> implements CalculusFieldElement<FieldTuple<T>> {
32  
33      /** Components of the tuple. */
34      private final T[] values;
35  
36      /** Field the instance belongs to. */
37      private final FieldTupleField<T> field;
38  
39      /** Creates a new instance from its components.
40       * @param x components of the tuple
41       */
42      @SafeVarargs
43      public FieldTuple(final T... x) {
44          this(new FieldTupleField<>(x[0].getField(), x.length), x.clone());
45      }
46  
47      /** Creates a new instance from its components.
48       * @param field field the instance belongs to
49       * @param x components of the tuple (beware, it is <em>not</em> copied, it is shared with caller)
50       */
51      private FieldTuple(final FieldTupleField<T> field, final T[] x) { // NOPMD - storing user-supplied array is intentional and documented here
52          this.values = x;
53          this.field  = field;
54      }
55  
56      /** {@inheritDoc} */
57      @Override
58      public FieldTuple<T> newInstance(final double value) {
59          return field.getZero().add(value);
60      }
61  
62      /** Get the dimension of the tuple.
63       * @return dimension of the tuple
64       */
65      public int getDimension() {
66          return values.length;
67      }
68  
69      /** Get one component of the tuple.
70       * @param index index of the component, between 0 and {@link #getDimension() getDimension()} - 1
71       * @return value of the component
72       */
73      public T getComponent(final int index) {
74          return values[index];
75      }
76  
77      /** Get all components of the tuple.
78       * @return all components
79       */
80      public T[] getComponents() {
81          return values.clone();
82      }
83  
84      /** {@inheritDoc} */
85      @Override
86      public Field<FieldTuple<T>> getField() {
87          return field;
88      }
89  
90      /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
178     @Override
179     public int hashCode() {
180         return  0x58f61de5 + Arrays.hashCode(values);
181     }
182 
183     /** {@inheritDoc} */
184     @Override
185     public double getReal() {
186         return values[0].getReal();
187     }
188 
189     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
231     @Override
232     public FieldTuple<T> square() {
233         return multiply(this);
234     }
235 
236     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** Field for {link FieldTuple} instances.
803      * @param <T> the type of the field elements
804      */
805     private static class FieldTupleField<T extends CalculusFieldElement<T>> implements Field<FieldTuple<T>> {
806 
807         /** Constant function evaluating to 0.0. */
808         private final FieldTuple<T> zero;
809 
810         /** Constant function evaluating to 1.0. */
811         private final FieldTuple<T> one;
812 
813         /** Simple constructor.
814          * @param field field to which the elements belong
815          * @param dimension dimension of the tuple
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         /** {@inheritDoc} */
827         @Override
828         public FieldTuple<T> getZero() {
829             return zero;
830         }
831 
832         /** {@inheritDoc} */
833         @Override
834         public FieldTuple<T> getOne() {
835             return one;
836         }
837 
838         /** {@inheritDoc} */
839         @SuppressWarnings("unchecked")
840         @Override
841         public Class<FieldTuple<T>> getRuntimeClass() {
842             return (Class<FieldTuple<T>>) zero.getClass();
843         }
844 
845         /** {@inheritDoc} */
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         /** {@inheritDoc} */
858         @Override
859         public int hashCode() {
860             return 0xb4a533e1 ^ zero.getDimension();
861         }
862 
863     }
864 
865 }