Class BaseRuleFactory<T extends java.lang.Number>

  • Type Parameters:
    T - Type of the number used to represent the points and weights of the quadrature rules.
    Direct Known Subclasses:
    HermiteRuleFactory, LegendreHighPrecisionRuleFactory, LegendreRuleFactory

    public abstract class BaseRuleFactory<T extends java.lang.Number>
    extends java.lang.Object
    Base class for rules that determines the integration nodes and their weights. Subclasses must implement the computeRule method.
    Since:
    3.1
    • Field Summary

      Fields 
      Modifier and Type Field Description
      private java.util.Map<java.lang.Integer,​Pair<T[],​T[]>> pointsAndWeights
      List of points and weights, indexed by the order of the rule.
      private java.util.Map<java.lang.Integer,​Pair<double[],​double[]>> pointsAndWeightsDouble
      Cache for double-precision rules.
    • Constructor Summary

      Constructors 
      Constructor Description
      BaseRuleFactory()  
    • Method Summary

      All Methods Static Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and Type Method Description
      protected void addRule​(Pair<T[],​T[]> rule)
      Stores a rule.
      protected abstract Pair<T[],​T[]> computeRule​(int numberOfPoints)
      Computes the rule for the given order.
      private static <T extends java.lang.Number>
      Pair<double[],​double[]>
      convertToDouble​(Pair<T[],​T[]> rule)
      Converts the from the actual Number type to double
      Pair<double[],​double[]> getRule​(int numberOfPoints)
      Gets a copy of the quadrature rule with the given number of integration points.
      protected Pair<T[],​T[]> getRuleInternal​(int numberOfPoints)
      Gets a rule.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • pointsAndWeights

        private final java.util.Map<java.lang.Integer,​Pair<T extends java.lang.Number[],​T extends java.lang.Number[]>> pointsAndWeights
        List of points and weights, indexed by the order of the rule.
      • pointsAndWeightsDouble

        private final java.util.Map<java.lang.Integer,​Pair<double[],​double[]>> pointsAndWeightsDouble
        Cache for double-precision rules.
    • Constructor Detail

      • BaseRuleFactory

        public BaseRuleFactory()
    • Method Detail

      • getRuleInternal

        protected Pair<T[],​T[]> getRuleInternal​(int numberOfPoints)
                                               throws DimensionMismatchException
        Gets a rule. Synchronization ensures that rules will be computed and added to the cache at most once. The returned rule is a reference into the cache.
        Parameters:
        numberOfPoints - Order of the rule to be retrieved.
        Returns:
        the points and weights corresponding to the given order.
        Throws:
        DimensionMismatchException - if the elements of the rule pair do not have the same length.
      • computeRule

        protected abstract Pair<T[],​T[]> computeRule​(int numberOfPoints)
                                                    throws DimensionMismatchException
        Computes the rule for the given order.
        Parameters:
        numberOfPoints - Order of the rule to be computed.
        Returns:
        the computed rule.
        Throws:
        DimensionMismatchException - if the elements of the pair do not have the same length.
      • convertToDouble

        private static <T extends java.lang.Number> Pair<double[],​double[]> convertToDouble​(Pair<T[],​T[]> rule)
        Converts the from the actual Number type to double
        Type Parameters:
        T - Type of the number used to represent the points and weights of the quadrature rules.
        Parameters:
        rule - Points and weights.
        Returns:
        points and weights as doubles.