LognormalRV.cpp

Go to the documentation of this file.
00001 /* ****************************************************************** **
00002 **    OpenSees - Open System for Earthquake Engineering Simulation    **
00003 **          Pacific Earthquake Engineering Research Center            **
00004 **                                                                    **
00005 **                                                                    **
00006 ** (C) Copyright 2001, The Regents of the University of California    **
00007 ** All Rights Reserved.                                               **
00008 **                                                                    **
00009 ** Commercial use of this program without express permission of the   **
00010 ** University of California, Berkeley, is strictly prohibited.  See   **
00011 ** file 'COPYRIGHT'  in main directory for information on usage and   **
00012 ** redistribution,  and for a DISCLAIMER OF ALL WARRANTIES.           **
00013 **                                                                    **
00014 ** Developed by:                                                      **
00015 **   Frank McKenna (fmckenna@ce.berkeley.edu)                         **
00016 **   Gregory L. Fenves (fenves@ce.berkeley.edu)                       **
00017 **   Filip C. Filippou (filippou@ce.berkeley.edu)                     **
00018 **                                                                    **
00019 ** Reliability module developed by:                                   **
00020 **   Terje Haukaas (haukaas@ce.berkeley.edu)                          **
00021 **   Armen Der Kiureghian (adk@ce.berkeley.edu)                       **
00022 **                                                                    **
00023 ** ****************************************************************** */
00024                                                                         
00025 // $Revision: 1.7 $
00026 // $Date: 2003/10/27 23:04:39 $
00027 // $Source: /usr/local/cvs/OpenSees/SRC/reliability/domain/distributions/LognormalRV.cpp,v $
00028 
00029 
00030 //
00031 // Written by Terje Haukaas (haukaas@ce.berkeley.edu)
00032 //
00033 
00034 #include <LognormalRV.h>
00035 #include <NormalRV.h>
00036 #include <math.h>
00037 #include <string.h>
00038 #include <classTags.h>
00039 #include <OPS_Globals.h>
00040 
00041 LognormalRV::LognormalRV(int passedTag, 
00042                  double passedMean,
00043                  double passedStdv,
00044                  double passedStartValue)
00045 :RandomVariable(passedTag, RANDOM_VARIABLE_lognormal)
00046 {
00047         if (passedMean<0.0) {
00048                 isPositive = false;
00049                 passedMean = -passedMean;
00050         }
00051         else {
00052                 isPositive = true;
00053         }
00054 
00055         tag = passedTag ;
00056         zeta = sqrt(   log(   1+(passedStdv/passedMean)*(passedStdv/passedMean)   )   );
00057         lambda = log(passedMean) - 0.5*zeta*zeta;
00058         startValue = passedStartValue;
00059 }
00060 
00061 
00062 
00063 LognormalRV::LognormalRV(int passedTag, 
00064                  double passedParameter1,
00065                  double passedParameter2,
00066                  double passedParameter3,
00067                  double passedParameter4,
00068                  double passedStartValue)
00069 :RandomVariable(passedTag, RANDOM_VARIABLE_lognormal)
00070 {
00071         if (passedParameter2<0.0) {
00072                 isPositive = false;
00073                 passedParameter2 = -passedParameter2;
00074         }
00075         else {
00076                 isPositive = true;
00077         }
00078 
00079         tag = passedTag ;
00080         lambda = passedParameter1;
00081         zeta = passedParameter2;
00082         startValue = passedStartValue;
00083 }
00084 
00085 
00086 
00087 LognormalRV::LognormalRV(int passedTag, 
00088                  double passedMean,
00089                  double passedStdv)
00090 :RandomVariable(passedTag, RANDOM_VARIABLE_lognormal)
00091 {
00092         if (passedMean<0.0) {
00093                 isPositive = false;
00094                 passedMean = -passedMean;
00095         }
00096         else {
00097                 isPositive = true;
00098         }
00099 
00100         tag = passedTag ;
00101         zeta = sqrt(   log(   1+(passedStdv/passedMean)*(passedStdv/passedMean)   )   );
00102         lambda = log(passedMean) - 0.5*zeta*zeta;
00103         startValue = getMean();
00104 }
00105 LognormalRV::LognormalRV(int passedTag, 
00106                  double passedParameter1,
00107                  double passedParameter2,
00108                  double passedParameter3,
00109                  double passedParameter4)
00110 :RandomVariable(passedTag, RANDOM_VARIABLE_lognormal)
00111 {
00112         if (passedParameter2<0.0) {
00113                 isPositive = false;
00114                 passedParameter2 = -passedParameter2;
00115         }
00116         else {
00117                 isPositive = true;
00118         }
00119 
00120         tag = passedTag ;
00121         lambda = passedParameter1;
00122         zeta = passedParameter2;
00123         startValue = getMean();
00124 }
00125 
00126 
00127 LognormalRV::~LognormalRV()
00128 {
00129 }
00130 
00131 
00132 void
00133 LognormalRV::Print(OPS_Stream &s, int flag)
00134 {
00135 }
00136 
00137 
00138 double
00139 LognormalRV::getPDFvalue(double rvValue)
00140 {
00141         if (!isPositive) {
00142                 // The formal answer is: f(x) = f_pos(x+2|x|), but let's do it simple here
00143                 rvValue = -rvValue;
00144         }
00145 
00146         double result;
00147         if ( 0.0 < rvValue ) {
00148                 double pi = 3.14159265358979;
00149                 result = 1/(sqrt(2*pi)*zeta*rvValue) * exp(-0.5* pow ( (log(rvValue)-lambda) / zeta, 2 )  );
00150         }
00151         else {
00152                 result = 0.0;
00153         }
00154         return result;
00155 }
00156 
00157 
00158 double
00159 LognormalRV::getCDFvalue(double rvValue)
00160 {
00161         double result;
00162 
00163         static NormalRV aStandardNormalRV( 1, 0.0, 1.0, 0.0);
00164         
00165         if (isPositive) {
00166                 if ( 0.0 < rvValue ) {
00167                         result = aStandardNormalRV.getCDFvalue((log(rvValue)-lambda)/zeta);
00168                 }
00169                 else {
00170                         result = 0.0;
00171                 }
00172         }
00173         else {
00174                 if ( rvValue < 0.0 ) {
00175                         result = aStandardNormalRV.getCDFvalue((log(fabs(rvValue))-lambda)/zeta);
00176                         result = 1.0-result;
00177                 }
00178                 else {
00179                         result = 1.0;
00180                 }
00181         }
00182 
00183         // Return result depending on type of random variable
00184         if (isPositive) {
00185                 return result;
00186         }
00187         else {
00188                 return 1-result;
00189         }
00190 
00191 
00192 
00193 /*
00194         // First, flip it around if it's a negative lognormal
00195         if (!isPositive) {
00196                 rvValue = -rvValue;
00197         }
00198 
00199         // Compute the ordinary CDF
00200         double result;
00201         if ( 0.0 < rvValue ) {
00202                 RandomVariable *aStandardNormalRV;
00203                 aStandardNormalRV= new NormalRV( 1, 0.0, 1.0, 0.0);
00204                 result = aStandardNormalRV->getCDFvalue((log(rvValue)-lambda)/zeta);
00205                 delete aStandardNormalRV;       
00206         }
00207         else {
00208                 result = 0.0;
00209         }
00210 
00211         // Return result depending on type of random variable
00212         if (isPositive) {
00213                 return result;
00214         }
00215         else {
00216                 return 1-result;
00217         }
00218 */
00219 }
00220 
00221 
00222 double
00223 LognormalRV::getInverseCDFvalue(double probValue)
00224 {
00225         if ( probValue > 1.0 || probValue < 0.0) {
00226                 opserr << "Invalid probability value input to inverse CDF function" << endln;
00227                 return 0.0;
00228         }
00229         else {
00230                 static NormalRV aStandardNormalRV( 1, 0.0, 1.0, 0.0);
00231 
00232                 if (isPositive) {
00233                         double inverseNormal = aStandardNormalRV.getInverseCDFvalue(probValue);
00234                         return exp(inverseNormal*zeta + lambda);
00235                 }
00236                 else {
00237                         double inverseNormal = aStandardNormalRV.getInverseCDFvalue(1.0-probValue);
00238                         return (-exp(inverseNormal*zeta + lambda));
00239                 }
00240         }
00241 }
00242 
00243 
00244 const char *
00245 LognormalRV::getType()
00246 {
00247         return "LOGNORMAL";
00248 }
00249 
00250 
00251 double 
00252 LognormalRV::getMean()
00253 {
00254         if (isPositive) {
00255                 return exp(lambda+0.5*zeta*zeta);
00256         }
00257         else {
00258                 return -exp(lambda+0.5*zeta*zeta);
00259         }
00260 }
00261 
00262 
00263 
00264 double 
00265 LognormalRV::getStdv()
00266 {
00267         return exp(lambda+0.5*zeta*zeta)*sqrt(exp(zeta*zeta)-1);
00268 }
00269 
00270 
00271 double 
00272 LognormalRV::getStartValue()
00273 {
00274         return startValue;
00275 }
00276 
00277 
00278 double LognormalRV::getParameter1()  {return lambda;}
00279 
00280 double LognormalRV::getParameter2()  
00281 {
00282         if (isPositive) {
00283                 return zeta;
00284         }
00285         else {
00286                 return -zeta;
00287         }
00288 }
00289 
00290 double LognormalRV::getParameter3()  {opserr<<"No such parameter in r.v. #"<<tag<<endln; return 0.0;}
00291 
00292 double LognormalRV::getParameter4()  {opserr<<"No such parameter in r.v. #"<<tag<<endln; return 0.0;}

Generated on Mon Oct 23 15:05:26 2006 for OpenSees by doxygen 1.5.0