janchaz
22 de Agosto del 2005

Hola,alguien tendria ya implementado la distribucion normal estandar inversa (0,1)...

Paul
22 de Agosto del 2005

Oigan, me sirvio mucho el algoritmo. Pero no tienen el que es para hallar la distribucion normal estandar (no la inversa).
Estoy buscando el algoritmo pero no lo encuentro por ningun sitio.
Saludos

carlos
22 de Agosto del 2005

hola, yo tambien necesito la codificación de la distribución estandar inversa, así que por favor, si te la hacen llegar, reenviamela vale?
mis correos son:
[email protected]
[email protected]
muchisimas gracias de antemano

Jorge
22 de Agosto del 2005

Hola janchaz. Antes de nada, para ver bien el contenido de este mensaje, selecionalo todo y pegalo en el bloc de notas
asegurandote que no está puesto el juste de linea (Formato->Ajuste de linea).
Buscando algún algoritmo más eficaz que el que yo he implementado me he encontrado contigo. Así
que te paso la función que he hecho, funciona bien, pero estaba buscando algún otro algoritmo que fuese más rápido.


/***************************************************************************************************************************/
// DEFINICION
// ----------
//
float NormalInversaEstandar(float p, long double dx=0.00001);
//
// p.- es la probabilidad para la que se quiere determinar el valor de Z
// dx.- es la resolución del cálculo de Z, a mayor resolución mayor exactidtud pero mayor tiempo para el cálculo.
// Este argumento esta puesto por defecto, con lo que no es necesario pasarse lo a la función a no ser que queramos
// otro diferente.
// Ej: determinar Z para una probabilidad normal de 1-alfa de 0.975 -> NormalInversaEstandar(0.975)
// determinar Z para una probabilidad normal de 1-alfa de 0.975 con una resolucion de 0.01-> NormalInversaEstandar(0.975, 0.01)
//
/***************************************************************************************************************************/

// DECLARACION
// -----------

float NormalInversaEstandar(float p, long double dx) // p es la probabilidad dada para una Z (buscada, es la que devuelve esta función), "dx" es la resolución con la que queremos que se realice el cálculo, a mas resolución más lento será el mismo
{
long double PI = 3.141592653589793238462643382795; // constante PI
long double K; // K Contendrá la inversa de la raiz cuadrada de 2*PI
K=(long double)(1)/sqrtl(2*PI); // aquí se hace
long double suma=0;
long double i = 0; // "i" contendrá la Z buscada
long double p_debajo50; //"p_debajo50" contendrá la probabilidad equivalente para una misma Z en valor absoluto (en las últimas lineas se corrige el signo)
if(dx > 0.1 || dx < 0) dx=0.00001; //si el valor pasado como resolución es errone, se corrige

if(p<=1 && p >0) //si la probabilidad pasada a la función es menor o igual que 0 y mayor que 1 (la probabilidad solo puede estar entre 0 y 1), la funcion devuelve 0 (esto se hace en la ultima linea de la función)
{
if(p<0.5)
p_debajo50 = 0.5-p;
else
p_debajo50 = p-0.5; //en esta, y en las dos lineas anteriores, se determina la probabilidad para la z (en valor absoluto) que es equivalente para la probabilidad dada

while(K*suma<=p_debajo50)
{
suma=suma+(expl(-powl(i,2)/2)*dx);
i=i+dx;
} //en este bucle while se calcula Z en valor absoluto
if(p<0.5)
return -i;
else
return i; //en esta linea y en las 3 anteriores se corrige el signo de Z al verdadero correspondiente a la probabilidad solicitada
}
else return 0; //si la probabilidad pasada a esta función es mayor a 1 o menor a 0, la función retorna un 0 indicando que se ha ocurrido esta situación
}
/***************************************************************************************************************************/

Esta función te calcula Z para una probabilidad tomada a partir de -infinito (cola inferior). Tal vez desees conocer +/-Z para
una probabilidad que esté centrada en la curva. Para ello puedes implementar la siguiente función:

float NormalIntervaloConfianza2Colas(float nc, long double dx) //nc es la probabilidad centrada (nc es de nivel de confianza), y dx es para la resolucion del cálculo
{
if(nc<=1 && nc >0)return NolmalInversaEstandar( nc + ((1-nc)/2), dx);
else return 0;
}

Si realizas alguna modificación que mejore la función te agradeceria que me la pasases.
Espero que te sirva.

Jorge Celso.