1 /* 2 * Licensed to the Apache Software Foundation (ASF) 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 ASF 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 18 package org.apache.commons.math.distribution; 19 20 import java.io.Serializable; 21 22 import org.apache.commons.math.MathRuntimeException; 23 24 /** 25 * Default implementation of 26 * {@link org.apache.commons.math.distribution.CauchyDistribution}. 27 * 28 * @since 1.1 29 * @version $Revision: 772119 $ $Date: 2009-05-06 05:43:28 -0400 (Wed, 06 May 2009) $ 30 */ 31 public class CauchyDistributionImpl extends AbstractContinuousDistribution 32 implements CauchyDistribution, Serializable { 33 34 /** Serializable version identifier */ 35 private static final long serialVersionUID = 8589540077390120676L; 36 37 /** The median of this distribution. */ 38 private double median = 0; 39 40 /** The scale of this distribution. */ 41 private double scale = 1; 42 43 /** 44 * Creates cauchy distribution with the medain equal to zero and scale 45 * equal to one. 46 */ 47 public CauchyDistributionImpl(){ 48 this(0.0, 1.0); 49 } 50 51 /** 52 * Create a cauchy distribution using the given median and scale. 53 * @param median median for this distribution 54 * @param s scale parameter for this distribution 55 */ 56 public CauchyDistributionImpl(double median, double s){ 57 super(); 58 setMedian(median); 59 setScale(s); 60 } 61 62 /** 63 * For this distribution, X, this method returns P(X < <code>x</code>). 64 * @param x the value at which the CDF is evaluated. 65 * @return CDF evaluted at <code>x</code>. 66 */ 67 public double cumulativeProbability(double x) { 68 return 0.5 + (Math.atan((x - median) / scale) / Math.PI); 69 } 70 71 /** 72 * Access the median. 73 * @return median for this distribution 74 */ 75 public double getMedian() { 76 return median; 77 } 78 79 /** 80 * Access the scale parameter. 81 * @return scale parameter for this distribution 82 */ 83 public double getScale() { 84 return scale; 85 } 86 87 /** 88 * For this distribution, X, this method returns the critical point x, such 89 * that P(X < x) = <code>p</code>. 90 * <p> 91 * Returns <code>Double.NEGATIVE_INFINITY</code> for p=0 and 92 * <code>Double.POSITIVE_INFINITY</code> for p=1.</p> 93 * 94 * @param p the desired probability 95 * @return x, such that P(X < x) = <code>p</code> 96 * @throws IllegalArgumentException if <code>p</code> is not a valid 97 * probability. 98 */ 99 @Override 100 public double inverseCumulativeProbability(double p) { 101 double ret; 102 if (p < 0.0 || p > 1.0) { 103 throw MathRuntimeException.createIllegalArgumentException( 104 "{0} out of [{1}, {2}] range", p, 0.0, 1.0); 105 } else if (p == 0) { 106 ret = Double.NEGATIVE_INFINITY; 107 } else if (p == 1) { 108 ret = Double.POSITIVE_INFINITY; 109 } else { 110 ret = median + scale * Math.tan(Math.PI * (p - .5)); 111 } 112 return ret; 113 } 114 115 /** 116 * Modify the median. 117 * @param median for this distribution 118 */ 119 public void setMedian(double median) { 120 this.median = median; 121 } 122 123 /** 124 * Modify the scale parameter. 125 * @param s scale parameter for this distribution 126 * @throws IllegalArgumentException if <code>sd</code> is not positive. 127 */ 128 public void setScale(double s) { 129 if (s <= 0.0) { 130 throw MathRuntimeException.createIllegalArgumentException( 131 "scale must be positive ({0})", s); 132 } 133 scale = s; 134 } 135 136 /** 137 * Access the domain value lower bound, based on <code>p</code>, used to 138 * bracket a CDF root. This method is used by 139 * {@link #inverseCumulativeProbability(double)} to find critical values. 140 * 141 * @param p the desired probability for the critical value 142 * @return domain value lower bound, i.e. 143 * P(X < <i>lower bound</i>) < <code>p</code> 144 */ 145 @Override 146 protected double getDomainLowerBound(double p) { 147 double ret; 148 149 if (p < .5) { 150 ret = -Double.MAX_VALUE; 151 } else { 152 ret = getMedian(); 153 } 154 155 return ret; 156 } 157 158 /** 159 * Access the domain value upper bound, based on <code>p</code>, used to 160 * bracket a CDF root. This method is used by 161 * {@link #inverseCumulativeProbability(double)} to find critical values. 162 * 163 * @param p the desired probability for the critical value 164 * @return domain value upper bound, i.e. 165 * P(X < <i>upper bound</i>) > <code>p</code> 166 */ 167 @Override 168 protected double getDomainUpperBound(double p) { 169 double ret; 170 171 if (p < .5) { 172 ret = getMedian(); 173 } else { 174 ret = Double.MAX_VALUE; 175 } 176 177 return ret; 178 } 179 180 /** 181 * Access the initial domain value, based on <code>p</code>, used to 182 * bracket a CDF root. This method is used by 183 * {@link #inverseCumulativeProbability(double)} to find critical values. 184 * 185 * @param p the desired probability for the critical value 186 * @return initial domain value 187 */ 188 @Override 189 protected double getInitialDomain(double p) { 190 double ret; 191 192 if (p < .5) { 193 ret = getMedian() - getScale(); 194 } else if (p > .5) { 195 ret = getMedian() + getScale(); 196 } else { 197 ret = getMedian(); 198 } 199 200 return ret; 201 } 202 }