JacobiPolynomials.java

  1. /* Copyright 2002-2020 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS 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.  *   http://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.orekit.propagation.semianalytical.dsst.utilities;

  19. import java.util.ArrayList;
  20. import java.util.HashMap;
  21. import java.util.List;
  22. import java.util.Map;

  24. import org.hipparchus.RealFieldElement;
  25. import org.hipparchus.analysis.differentiation.DerivativeStructure;
  26. import org.hipparchus.analysis.differentiation.FieldDerivativeStructure;
  27. import org.hipparchus.analysis.differentiation.FieldGradient;
  28. import org.hipparchus.analysis.differentiation.Gradient;
  29. import org.hipparchus.analysis.polynomials.PolynomialFunction;
  30. import org.hipparchus.analysis.polynomials.PolynomialsUtils;

  32. /** Provider of the Jacobi polynomials P<sub>l</sub><sup>v,w</sup>.
  33.  * <p>
  34.  * This class is used for {@link
  35.  * org.orekit.propagation.semianalytical.dsst.forces.DSSTTesseral
  36.  * tesseral contribution} computation.
  37.  * </p>
  38.  *
  39.  * @author Nicolas Bernard
  40.  * @since 6.1
  41.  */
  42. public class JacobiPolynomials {

  44.     /** Storage map. */
  45.     private static final Map<JacobiKey, List<PolynomialFunction>> MAP =
  46.             new HashMap<JacobiPolynomials.JacobiKey, List<PolynomialFunction>>();

  48.     /** Private constructor as class is a utility. */
  49.     private JacobiPolynomials() {
  50.     }

  52.     /** Returns the value and derivatives of the Jacobi polynomial P<sub>l</sub><sup>v,w</sup> evaluated at γ.
  53.      * <p>
  54.      * This method is guaranteed to be thread-safe
  55.      * </p>
  56.      * @param l degree of the polynomial
  57.      * @param v v value
  58.      * @param w w value
  59.      * @param gamma γ value
  60.      * @return value and derivatives of the Jacobi polynomial P<sub>l</sub><sup>v,w</sup>(γ)
  61.      * @deprecated as of 10.2, replaced by {@link #getValue(int, int, int, Gradient)}
  62.      */
  63.     @Deprecated
  64.     public static DerivativeStructure getValue(final int l, final int v, final int w, final DerivativeStructure gamma) {

  66.         final List<PolynomialFunction> polyList;
  67.         synchronized (MAP) {

  69.             final JacobiKey key = new JacobiKey(v, w);

  71.             // Check the existence of the corresponding key in the map.
  72.             if (!MAP.containsKey(key)) {
  73.                 MAP.put(key, new ArrayList<PolynomialFunction>());
  74.             }

  76.             polyList = MAP.get(key);

  78.         }

  80.         final PolynomialFunction polynomial;
  81.         synchronized (polyList) {
  82.             // If the l-th degree polynomial has not been computed yet, the polynomials
  83.             // up to this degree are computed.
  84.             for (int degree = polyList.size(); degree <= l; degree++) {
  85.                 polyList.add(degree, PolynomialsUtils.createJacobiPolynomial(degree, v, w));
  86.             }
  87.             polynomial = polyList.get(l);
  88.         }

  90.         // compute value and derivative
  91.         return polynomial.value(gamma);

  93.     }

  95.     /** Returns the value and derivatives of the Jacobi polynomial P<sub>l</sub><sup>v,w</sup> evaluated at γ.
  96.      * <p>
  97.      * This method is guaranteed to be thread-safe
  98.      * </p>
  99.      * @param l degree of the polynomial
  100.      * @param v v value
  101.      * @param w w value
  102.      * @param gamma γ value
  103.      * @return value and derivatives of the Jacobi polynomial P<sub>l</sub><sup>v,w</sup>(γ)
  104.      * @since 10.2
  105.      */
  106.     public static Gradient getValue(final int l, final int v, final int w, final Gradient gamma) {

  108.         final List<PolynomialFunction> polyList;
  109.         synchronized (MAP) {

  111.             final JacobiKey key = new JacobiKey(v, w);

  113.             // Check the existence of the corresponding key in the map.
  114.             if (!MAP.containsKey(key)) {
  115.                 MAP.put(key, new ArrayList<PolynomialFunction>());
  116.             }

  118.             polyList = MAP.get(key);

  120.         }

  122.         final PolynomialFunction polynomial;
  123.         synchronized (polyList) {
  124.             // If the l-th degree polynomial has not been computed yet, the polynomials
  125.             // up to this degree are computed.
  126.             for (int degree = polyList.size(); degree <= l; degree++) {
  127.                 polyList.add(degree, PolynomialsUtils.createJacobiPolynomial(degree, v, w));
  128.             }
  129.             polynomial = polyList.get(l);
  130.         }

  132.         // compute value and derivative
  133.         return polynomial.value(gamma);

  135.     }

  137.     /** Returns the value and derivatives of the Jacobi polynomial P<sub>l</sub><sup>v,w</sup> evaluated at γ.
  138.      * <p>
  139.      * This method is guaranteed to be thread-safe
  140.      * </p>
  141.      * @param <T> the type of the field elements
  142.      * @param l degree of the polynomial
  143.      * @param v v value
  144.      * @param w w value
  145.      * @param gamma γ value
  146.      * @return value and derivatives of the Jacobi polynomial P<sub>l</sub><sup>v,w</sup>(γ)
  147.      * @deprecated as of 10.2, replace by {@link #getValue(int, int, int, FieldDerivativeStructure)}
  148.      */
  149.     @Deprecated
  150.     public static <T extends RealFieldElement<T>> FieldDerivativeStructure<T> getValue(final int l, final int v, final int w,
  151.                                                                                        final FieldDerivativeStructure<T> gamma) {

  153.         final List<PolynomialFunction> polyList;
  154.         synchronized (MAP) {

  156.             final JacobiKey key = new JacobiKey(v, w);

  158.             // Check the existence of the corresponding key in the map.
  159.             if (!MAP.containsKey(key)) {
  160.                 MAP.put(key, new ArrayList<PolynomialFunction>());
  161.             }

  163.             polyList = MAP.get(key);

  165.         }

  167.         final PolynomialFunction polynomial;
  168.         synchronized (polyList) {
  169.             // If the l-th degree polynomial has not been computed yet, the polynomials
  170.             // up to this degree are computed.
  171.             for (int degree = polyList.size(); degree <= l; degree++) {
  172.                 polyList.add(degree, PolynomialsUtils.createJacobiPolynomial(degree, v, w));
  173.             }
  174.             polynomial = polyList.get(l);
  175.         }

  177.         // compute value and derivative
  178.         return polynomial.value(gamma);

  180.     }

  182.     /** Returns the value and derivatives of the Jacobi polynomial P<sub>l</sub><sup>v,w</sup> evaluated at γ.
  183.      * <p>
  184.      * This method is guaranteed to be thread-safe
  185.      * </p>
  186.      * @param <T> the type of the field elements
  187.      * @param l degree of the polynomial
  188.      * @param v v value
  189.      * @param w w value
  190.      * @param gamma γ value
  191.      * @return value and derivatives of the Jacobi polynomial P<sub>l</sub><sup>v,w</sup>(γ)
  192.      * @since 10.2
  193.      */
  194.     public static <T extends RealFieldElement<T>> FieldGradient<T> getValue(final int l, final int v, final int w,
  195.                                                                             final FieldGradient<T> gamma) {

  197.         final List<PolynomialFunction> polyList;
  198.         synchronized (MAP) {

  200.             final JacobiKey key = new JacobiKey(v, w);

  202.             // Check the existence of the corresponding key in the map.
  203.             if (!MAP.containsKey(key)) {
  204.                 MAP.put(key, new ArrayList<PolynomialFunction>());
  205.             }

  207.             polyList = MAP.get(key);

  209.         }

  211.         final PolynomialFunction polynomial;
  212.         synchronized (polyList) {
  213.             // If the l-th degree polynomial has not been computed yet, the polynomials
  214.             // up to this degree are computed.
  215.             for (int degree = polyList.size(); degree <= l; degree++) {
  216.                 polyList.add(degree, PolynomialsUtils.createJacobiPolynomial(degree, v, w));
  217.             }
  218.             polynomial = polyList.get(l);
  219.         }

  221.         // compute value and derivative
  222.         return polynomial.value(gamma);

  224.     }

  226.     /** Inner class for Jacobi polynomials keys.
  227.      * <p>
  228.      * Please note that this class is not original content but is a copy from the
  229.      * Hipparchus library. This library is published under the
  230.      * Apache License, version 2.0.
  231.      * </p>
  232.      *
  233.      * @see org.hipparchus.analysis.polynomials.PolynomialsUtils
  234.      */
  235.     private static class JacobiKey {

  237.         /** First exponent. */
  238.         private final int v;

  240.         /** Second exponent. */
  241.         private final int w;

  243.         /** Simple constructor.
  244.          * @param v first exponent
  245.          * @param w second exponent
  246.          */
  247.         JacobiKey(final int v, final int w) {
  248.             this.v = v;
  249.             this.w = w;
  250.         }

  252.         /** Get hash code.
  253.          * @return hash code
  254.          */
  255.         @Override
  256.         public int hashCode() {
  257.             return (v << 16) ^ w;
  258.         }

  260.         /** Check if the instance represent the same key as another instance.
  261.          * @param key other key
  262.          * @return true if the instance and the other key refer to the same polynomial
  263.          */
  264.         @Override
  265.         public boolean equals(final Object key) {

  267.             if ((key == null) || !(key instanceof JacobiKey)) {
  268.                 return false;
  269.             }

  271.             final JacobiKey otherK = (JacobiKey) key;
  272.             return (v == otherK.v) && (w == otherK.w);

  274.         }
  275.     }

  277. }
Created with JaCoCo 0.8.6.202009150832