MtasDataDoubleOperations.java

  1. package mtas.codec.util.collector;

  2. import java.io.Serializable;

  3. /**
  4.  * The Class MtasDataDoubleOperations.
  5.  */
  6. class MtasDataDoubleOperations
  7.     implements MtasDataOperations<Double, Double>, Serializable {

  8.   /** The Constant serialVersionUID. */
  9.   private static final long serialVersionUID = 1L;

  10.   /*
  11.    * (non-Javadoc)
  12.    *
  13.    * @see mtas.codec.util.DataCollector.MtasDataOperations#product11(java.lang.
  14.    * Number, java.lang.Number)
  15.    */
  16.   @Override
  17.   public Double product11(Double arg1, Double arg2) {
  18.     if (arg1 == null || arg2 == null) {
  19.       return Double.NaN;
  20.     } else {
  21.       return arg1 * arg2;
  22.     }
  23.   }

  24.   /*
  25.    * (non-Javadoc)
  26.    *
  27.    * @see
  28.    * mtas.codec.util.DataCollector.MtasDataOperations#add11(java.lang.Number,
  29.    * java.lang.Number)
  30.    */
  31.   @Override
  32.   public Double add11(Double arg1, Double arg2) {
  33.     if (arg1 == null || arg2 == null) {
  34.       return Double.NaN;
  35.     } else {
  36.       return arg1 + arg2;
  37.     }
  38.   }

  39.   /*
  40.    * (non-Javadoc)
  41.    *
  42.    * @see
  43.    * mtas.codec.util.DataCollector.MtasDataOperations#add22(java.lang.Number,
  44.    * java.lang.Number)
  45.    */
  46.   @Override
  47.   public Double add22(Double arg1, Double arg2) {
  48.     if (arg1 == null || arg2 == null) {
  49.       return Double.NaN;
  50.     } else {
  51.       return arg1 + arg2;
  52.     }
  53.   }

  54.   /*
  55.    * (non-Javadoc)
  56.    *
  57.    * @see mtas.codec.util.DataCollector.MtasDataOperations#subtract12(java.lang.
  58.    * Number, java.lang.Number)
  59.    */
  60.   @Override
  61.   public Double subtract12(Double arg1, Double arg2) {
  62.     if (arg1 == null || arg2 == null) {
  63.       return Double.NaN;
  64.     } else {
  65.       return arg1 - arg2;
  66.     }
  67.   }

  68.   /*
  69.    * (non-Javadoc)
  70.    *
  71.    * @see mtas.codec.util.DataCollector.MtasDataOperations#divide1(java.lang.
  72.    * Number, long)
  73.    */
  74.   @Override
  75.   public Double divide1(Double arg1, long arg2) {
  76.     if (arg1 == null) {
  77.       return Double.NaN;
  78.     } else {
  79.       return arg1 / arg2;
  80.     }
  81.   }

  82.   /*
  83.    * (non-Javadoc)
  84.    *
  85.    * @see mtas.codec.util.DataCollector.MtasDataOperations#divide2(java.lang.
  86.    * Number, long)
  87.    */
  88.   @Override
  89.   public Double divide2(Double arg1, long arg2) {
  90.     if (arg1 == null) {
  91.       return Double.NaN;
  92.     } else {
  93.       return arg1 / arg2;
  94.     }
  95.   }

  96.   /*
  97.    * (non-Javadoc)
  98.    *
  99.    * @see
  100.    * mtas.codec.util.DataCollector.MtasDataOperations#min11(java.lang.Number,
  101.    * java.lang.Number)
  102.    */
  103.   @Override
  104.   public Double min11(Double arg1, Double arg2) {
  105.     if (arg1 == null || arg2 == null) {
  106.       return Double.NaN;
  107.     } else {
  108.       return Math.min(arg1, arg2);
  109.     }
  110.   }

  111.   /*
  112.    * (non-Javadoc)
  113.    *
  114.    * @see
  115.    * mtas.codec.util.DataCollector.MtasDataOperations#max11(java.lang.Number,
  116.    * java.lang.Number)
  117.    */
  118.   @Override
  119.   public Double max11(Double arg1, Double arg2) {
  120.     if (arg1 == null || arg2 == null) {
  121.       return Double.NaN;
  122.     } else {
  123.       return Math.max(arg1, arg2);
  124.     }
  125.   }

  126.   /*
  127.    * (non-Javadoc)
  128.    *
  129.    * @see
  130.    * mtas.codec.util.DataCollector.MtasDataOperations#exp2(java.lang.Number)
  131.    */
  132.   @Override
  133.   public Double exp2(Double arg1) {
  134.     if (arg1 == null) {
  135.       return Double.NaN;
  136.     } else {
  137.       return Math.exp(arg1);
  138.     }
  139.   }

  140.   /*
  141.    * (non-Javadoc)
  142.    *
  143.    * @see
  144.    * mtas.codec.util.DataCollector.MtasDataOperations#sqrt2(java.lang.Number)
  145.    */
  146.   @Override
  147.   public Double sqrt2(Double arg1) {
  148.     if (arg1 == null) {
  149.       return Double.NaN;
  150.     } else {
  151.       return Math.sqrt(arg1);
  152.     }
  153.   }

  154.   /*
  155.    * (non-Javadoc)
  156.    *
  157.    * @see
  158.    * mtas.codec.util.DataCollector.MtasDataOperations#log1(java.lang.Number)
  159.    */
  160.   @Override
  161.   public Double log1(Double arg1) {
  162.     if (arg1 == null) {
  163.       return Double.NaN;
  164.     } else {
  165.       return Math.log(arg1);
  166.     }
  167.   }

  168.   /*
  169.    * (non-Javadoc)
  170.    *
  171.    * @see mtas.codec.util.DataCollector.MtasDataOperations#createVector1(int)
  172.    */
  173.   @Override
  174.   public Double[] createVector1(int length) {
  175.     return new Double[length];
  176.   }

  177.   /*
  178.    * (non-Javadoc)
  179.    *
  180.    * @see mtas.codec.util.DataCollector.MtasDataOperations#createVector2(int)
  181.    */
  182.   @Override
  183.   public Double[] createVector2(int length) {
  184.     return new Double[length];
  185.   }

  186.   /*
  187.    * (non-Javadoc)
  188.    *
  189.    * @see mtas.codec.util.DataCollector.MtasDataOperations#createMatrix1(int)
  190.    */
  191.   @Override
  192.   public Double[][] createMatrix1(int length) {
  193.     return new Double[length][];
  194.   }

  195.   /*
  196.    * (non-Javadoc)
  197.    *
  198.    * @see mtas.codec.util.DataCollector.MtasDataOperations#getZero1()
  199.    */
  200.   @Override
  201.   public Double getZero1() {
  202.     return Double.valueOf(0);
  203.   }

  204.   /*
  205.    * (non-Javadoc)
  206.    *
  207.    * @see mtas.codec.util.DataCollector.MtasDataOperations#getZero2()
  208.    */
  209.   @Override
  210.   public Double getZero2() {
  211.     return Double.valueOf(0);
  212.   }

  213. }