//Copyright - 2000-2009 Alfredo J G A Borba. Todos os Direitos Reservados


//Tratamento de Erros
function FaltaArg() {
	 alert("Função faltando argumento");
}
//Fim de Tratamento de Erros


//Funções Especiais
function ABS(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	return Math.abs(num);
}

function ACOS(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<-1 || num>1) {alert("O valor do argumento deve estar entre -1 e 1"); return;}
	return Math.acos(num);
}

function ACOSECH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num==0) {alert("O valor do argumento deve ser diferente de 0"); return;}
	var valor = Math.log((1/num)+Math.sqrt((1/(num*num))+1));	
	return valor;
}

function ACOSH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<1) {alert("O valor do argumento deve ser maior ou igual a 1"); return;}
	var valor = Math.log(num+Math.sqrt(num*num-1));	
	return valor;
}

function ACOTANH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num>=-1 && num<=1) {alert("O valor do argumento deve ser menor que -1 ou maior que 1 \n(x<-1< ou x>1)"); return;}
	var valor = Math.log((num+1)/(num-1))/2;	
	return valor;
}

function ALEATORIO() {
	return Math.random();
}

function ALEATORIOENTRE(inferior, superior) {
	if (isNaN(parseFloat(inferior)) || isNaN(parseFloat(superior))) {FaltaArg(); return;}
	if (inferior>superior) {alert("O valor do argumento 1 deve ser menor do que o valor do argumento 2"); return;}
	inferior = parseInt(inferior);
	superior = parseInt(superior);
	var valor = Math.round(Math.random()*(superior-inferior)+inferior);
	return valor;
}

function AMP(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "amp", 1);
}

function ARRED(num, dec) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (isNaN(parseFloat(dec))) {dec = 0;}	
	var multdec = Math.pow(10,dec);
	var valor = Math.round(multdec*num)/multdec;	
	return valor;
}

function ASECH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<=0 || num>1) {alert("O valor do argumento deve estar entre 0 e 1 \n(0< x <=1)"); return;}
	var valor = Math.log((1/num)+Math.sqrt((1/(num*num))-1));	
	return valor;
}

function ASEN(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<-1 || num>1) {alert("O valor do argumento deve estar entre -1 e 1"); return;}
	return Math.asin(num);
}

function ASENH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = Math.log(num+Math.sqrt(num*num+1));	
	return valor;
}

function ASSIMETRIA(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "assimetria", 1);
	if (valor!="NA") {return valor;}
	else {return alert("Não é possível calcular a Assimetria")}
}

function ASSIMETRIAP(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "assimetria", 2);
	if (valor!="NA") {return valor;}
	else {return alert("Não é possível calcular a Assimetria")}
}

function ATAN(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	return Math.atan(num);
}

function ATAN2(num_x, num_y) {
	if (isNaN(parseFloat(num_x)) || isNaN(parseFloat(num_y))) {FaltaArg(); return;}	
	var valor = num_y/num_x;	
	if (num_x==0) {
		valor = (num_y!=0)? Number.POSITIVE_INFINITY : 0;
	}
	var atan_2 = Math.atan(valor);	
	if (num_x<=0) {
		if ((num_y>0 && num_x!=0)  || (num_y==0 && num_x<0)) {atan_2 += Math.PI;}
		if (num_y<0) {atan_2 -= Math.PI;}
	}
	return atan_2;
}

function ATANH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<=-1 || num>=1) {alert("O valor do argumento deve estar entre -1 e 1 \n(-1< x <1)"); return;}
	var valor = Math.log((1+num)/(1-num))/2;	
	return valor;
}

function BHP(q, h, d, ef, unid) {
	if (isNaN(parseFloat(q))) {FaltaArg(); return;}
	if (isNaN(parseFloat(h))) {FaltaArg(); return;}
	var ef_stg = ef+"";
	var bhp = 0;
	q = parseFloat(q);
	h = parseFloat(h);
	d = parseFloat(d);
	ef = parseFloat(ef);
	unid = parseFloat(unid);	
	if (isNaN(unid)) {unid = 0;}
	if (isNaN(d)) {d = 1;}
	if (isNaN(ef)) {ef = 0.6;}
	if (ef_stg.indexOf("%")!=-1) {
		ef = parseFloat(ef_stg.slice(0, ef_stg.indexOf("%")))/100;
	}
	if (unid==0) {
		bhp = q * h * d / (273.74 * ef);
	}
	else if (unid==1) {
		bhp = q * h * d / (3960 * ef);
	}
	if (bhp<0) {
		alert("O valor do BHP não pode ser negativo.\n\nVerifique os dados e tente novamente.");
		return;
	}	
	return bhp;
}

function BKW(q, h, d, ef, unid) {
	if (isNaN(parseFloat(q))) {FaltaArg(); return;}
	if (isNaN(parseFloat(h))) {FaltaArg(); return;}
	var ef_stg = ef+"";
	var bkw = 0;
	q = parseFloat(q);
	h = parseFloat(h);
	d = parseFloat(d);
	ef = parseFloat(ef);
	unid = parseFloat(unid);	
	if (isNaN(unid)) {unid = 0;}
	if (isNaN(d)) {d = 1;}
	if (isNaN(ef)) {ef = 0.6;}
	if (ef_stg.indexOf("%")!=-1) {
		ef = parseFloat(ef_stg.slice(0, ef_stg.indexOf("%")))/100;
	}
	if (unid==0) {
		bkw = q * h * d / (367.1 * ef);	
	}
	else if (unid==1) {
		bkw = q * h * d / (5310.45 * ef);
	}
	if (bkw<0) {
		alert("O valor do BKW não pode ser negativo.\n\nVerifique os dados e tente novamente.");
		return;
	}	
	return bkw;
}

function CODIGO(texto, ind) {
	if (texto=="" || texto==null) {FaltaArg(); return;}	
	if (isNaN(parseFloat(ind))) {ind = 0;}
	return texto.charCodeAt(ind);
}

function COMBIN(num1, num2) {
	if (isNaN(parseFloat(num1))) {FaltaArg(); return;}
	if (isNaN(parseFloat(num2))) {num2 = 0;}	
	if (num1<num2) {alert("O valor do argumento 1 deve ser maior do que o valor do argumento 2"); return;}
	if (num1<0 || num2<0) {alert("Os argumentos devem ser positivos"); return;}
	num1 = parseInt(num1);
	num2 = parseInt(num2);	
	var valor = FATORIAL(num1)/(FATORIAL(num2)*FATORIAL(num1-num2));	
	return valor;
}

function CONTAR(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "contagem", 1);
}

function CORREL(lista1, lista2) {
	if (lista1==null || lista2==null) {FaltaArg(); return;}
	var valor = 0;
	var desv_pad1 = DESVPADP(lista1);
	var desv_pad2 = DESVPADP(lista2);
	if (desv_pad1*desv_pad2==0) {alert("O Desvio-Padrão de pelo menos uma das listas de observações é igual a 0.\nA função CORREL não pode ser calculada"); return;}
	var covar = COVAR(lista1, lista2);
	valor = covar/(desv_pad1*desv_pad2);		
	return valor;
}

function COS(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	return Math.cos(num);
}

function COSEC(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = (num!=0)? 1/Math.sin(num) : 1/Math.sin(Math.PI);	
	return valor;
}

function COSECH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = (num!=0)? 1/SENH(num) : Math.tan(Math.PI/2);
	return valor;
}

function COSH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = (Math.exp(num) + Math.exp(-num))/2;	
	return valor;
}

function COTAN(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = (num!=0)? 1/Math.tan(num) : -1/Math.tan(Math.PI);	
	return valor;
}

function COTANH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = (num!=0)? COSH(num)/SENH(num) : Math.tan(Math.PI/2);
	return valor;
}

function COVAR(lista1, lista2) {
	if (lista1==null || lista2==null) {FaltaArg(); return;}
	var observ1 = lista1.slice(1,lista1.length-1);
	var observ2 = lista2.slice(1,lista2.length-1);	
	var valor = 0;
	var media1 = MEDIA(lista1);
	var media2 = MEDIA(lista2);
	MatrizDados(observ1, observ2);
	if (MatDados1.length!=MatDados2.length) {alert("As listas de observações devem ter a mesma quantidade de dados"); return;}
	var N = MatDados1.length;
	for (var k = 0; k <= MatDados1.length - 1; k++) {
		valor += (MatDados1[k]-media1) * (MatDados2[k]-media2);
	}
	valor = valor/N;		
	return valor;
}

function CURT(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "curtose", 1);
	if (valor!="NA") {return valor;}
	else {return alert("Não é possível calcular a Curtose")}
}

function CURTP(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "curtose", 2);
	if (valor!="NA") {return valor;}
	else {return alert("Não é possível calcular a Curtose")}
}

function CV(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "cv", 1);
	if (valor!="NA") {return valor;}
	else {return alert("Não é possível calcular o CV")}
}

function CVP(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "cv", 2);
}

function DESVPAD(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "desv_pad", 1);
	if (valor!="NA") {return valor;}
	else {return alert("Não é possível calcular o Desvio Padrão")} 
}

function DESVPADP(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "desv_pad", 2);
}

function DISTBINOM(num_s, tentativas, prob_s, acum) {
	if (isNaN(parseFloat(num_s))) {FaltaArg(); return;}
	if (isNaN(parseFloat(acum))) {acum = 0;}	
	if (num_s<0 || tentativas<0) {alert("Os argumentos 1 e 2 devem ser maiores do que 0"); return;}
	if (num_s>tentativas) {alert("O argumentos 1 deve ser menor do que o argumento 2"); return;}
	if (prob_s<0 || prob_s>1) {alert("O argumento 3 (probabilidade_s) deve ter o valor entre 0 e 1"); return;}
	if (acum!=0 && acum!=1) {alert("O valor do argumento 4 (acumulado) deve ser igual a 0 (Falso) ou igual a 1 (Verdadeiro)"); return;}	
	num_s = parseInt(num_s);
	tentativas = parseInt(tentativas);
	var valor = 0;	
	if (acum==0) {
		valor = COMBIN(tentativas, num_s)*Math.pow(prob_s, num_s)*Math.pow((1-prob_s),(tentativas-num_s));
	}
	else if (acum==1) {
		for (var i=0; i<=num_s; i++) {
			valor += DISTBINOM(i, tentativas, prob_s, 0);			
		}
	}
	return valor;
}

function DISTEXPON(num, lambda, acum) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (isNaN(parseFloat(acum))) {acum = 0;}
	if (num<0) {alert("O valor do argumento 1 (x) deve ser maior ou igual a 0"); return;}
	if (lambda<=0) {alert("O valor do argumento 2 (Lambda) deve ser maior do que 0"); return;}
	if (acum!=0 && acum!=1) {alert("O valor do argumento 3 (acumulado) deve ser igual a 0 (Falso) ou igual a 1 (Verdadeiro)"); return;}
	var valor = 0;	
	if (acum==0) {
		valor = lambda*Math.exp(-1*lambda*num);
	}
	else if (acum==1) {
		valor = 1-Math.exp(-1*lambda*num);
	}
	return valor;
}

function DISTGAMA(num, alfa, beta, acum) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (isNaN(parseFloat(acum))) {acum = 0;}	
	if (num<0) {alert("O argumento 1 deve ser maior ou igual a 0"); return;}
	if (alfa<=0) {alert("O argumento 2 (Alfa) deve ser maior do que 0"); return;}
	if (beta<=0) {alert("O argumento 3 (Beta) deve ser maior do que 0"); return;}
	if (acum!=0 && acum!=1) {alert("O valor do argumento 4 (acumulado) deve ser igual a 0 (Falso) ou igual a 1 (Verdadeiro)"); return;}	
	var valor = 0;	
	if (acum==0) {		
		valor = (Math.pow(num,(alfa-1))*Math.exp(-1*num/beta))/(Math.pow(beta,alfa)*GAMA(alfa));
	}
	else if (acum==1) {				
		_alfa = alfa;
		_beta = beta;
		valor = Integral(_DistGama, 0, num, 1e-10);
	}
	return valor;
}

function DISTLOGNORM(num, media, desv_pad, acum) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (isNaN(parseFloat(acum))) {acum = 0;}
	if (num<=0) {alert("O argumento 1 deve ser maior do que 0"); return;}	
	if (desv_pad<=0) {alert("O argumento 3 (Desvio Padrão) deve ser maior do que 0"); return;}
	if (acum!=0 && acum!=1) {alert("O valor do argumento 4 (acumulado) deve ser igual a 0 (Falso) ou igual a 1 (Verdadeiro)"); return;}	
	var valor = 0;	
	if (acum==0) {
		valor = Math.exp((-1*(LN(num)-media)*(LN(num)-media)/(2*desv_pad*desv_pad)))/(desv_pad*Math.sqrt(2*Math.PI));
	}
	else if (acum==1) {	
		var z = (LN(num)-media)/desv_pad;
		valor = DISTNORMP(z);
	}
	return valor;
}

function DISTNORM(num, media, desv_pad, acum) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (isNaN(parseFloat(acum))) {acum = 0;}	
	if (desv_pad<=0) {alert("O argumento 3 (Desvio Padrão) deve ser maior do que 0"); return;}
	if (acum!=0 && acum!=1) {alert("O valor do argumento 4 (acumulado) deve ser igual a 0 (Falso) ou igual a 1 (Verdadeiro)"); return;}	
	var valor = 0;	
	if (acum==0) {
		valor = Math.exp((-1*(num-media)*(num-media)/(2*desv_pad*desv_pad)))/(desv_pad*Math.sqrt(2*Math.PI));
	}
	else if (acum==1) {
		var z = (num-media)/desv_pad;		
		valor = DISTNORMP(z);
	}
	return valor;
}

function DISTNORMP(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	return Integral(_DistNormP, Number.NEGATIVE_INFINITY, num, 1e-10);
}

function DISTQUI(num, graus_lib) {
	if (isNaN(parseFloat(num)) || isNaN(parseFloat(graus_lib))) {FaltaArg(); return;}
	if (num<0) {alert("O valor do argumento 1 deve ser maior ou igual a 0"); return;}
	if (graus_lib<1) {alert("O valor do argumento 2 (Graus de Liberdade) deve ser maior ou igual a 1"); return;}
	_graus_lib = parseInt(graus_lib);
	return Integral(_DistQUI, num, Number.POSITIVE_INFINITY, 1e-10);
}

function DISTT(t, graus_lib) {
	if (isNaN(parseFloat(t)) || isNaN(parseFloat(graus_lib))) {FaltaArg(); return;}
	if (t<0) {alert("O valor do argumento 1 (t) deve ser maior ou igual a 0"); return;}
	if (graus_lib<1) {alert("O valor do argumento 2 (Graus de Liberdade) deve ser maior ou igual a 1"); return;}
	_graus_lib = parseInt(graus_lib);
	return Integral(_DistT, t, Number.POSITIVE_INFINITY, 1e-7);
}

function E() {
	return Math.E;
}

function EPADYX(lista1, lista2) {
	if (lista1==null || lista2==null) {FaltaArg(); return;}
	var observ1 = lista1.slice(1,lista1.length-1);
	var observ2 = lista2.slice(1,lista2.length-1);	
	var valor = 0;
	var soma_x = 0;
	var soma_x2 = 0;
	var soma_y = 0;
	var soma_y2 = 0;
	var soma_xy = 0;	
	MatrizDados(observ1, observ2);
	if (MatDados1.length!=MatDados2.length) {alert("As listas de observações devem ter a mesma quantidade de dados"); return;}
	var N = MatDados1.length;
	for (var k = 0; k <= MatDados1.length - 1; k++) {
		soma_x += MatDados2[k];
		soma_x2 += MatDados2[k]*MatDados2[k];
		soma_y += MatDados1[k];
		soma_y2 += MatDados1[k]*MatDados1[k];
		soma_xy += MatDados2[k]*MatDados1[k];
	}
	valor = (N*soma_y2 - (soma_y*soma_y))-((N*soma_xy-(soma_x*soma_y))*(N*soma_xy-(soma_x*soma_y)))/(N*soma_x2 - (soma_x*soma_x));	
	valor = valor/(N*(N-2));
	valor = Math.sqrt(valor);		
	return valor;
}

function ERROPAD(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "erro_pad", 1);
	if (valor!="NA") {return valor;}
	else {return alert("Não é possível calcular o Erro Padrão")}
}

function EXP(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	return Math.exp(num);
}

function FATORIAL(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<0) {alert("O valor do argumento da função FATORIAL deve ser maior ou igual a 0"); return;}
	num = parseInt(num);
	var valor = num;	
	for (var i=1; i<num; i++) {
		valor*= num-i;
	}
	if (num==0) {valor = 1;}	
	return valor;
}

function FISHER(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<=-1 || num>=1) {alert("O valor do argumento da função FISHER deve estar entre -1 e 1 \n(-1< x <1)"); return;}
	var valor = Math.log((1+num)/(1-num))/2;	
	return valor;
}

function FISHERINV(num) {
	return TANH(num);
}

function GAMA(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
    var valor;
	with(Math) {
        if ( num <= 0 ) {
            if (abs(num)-floor(abs(num))==0 ) {
                alert ("Não é possível calcular a função GAMA para o valor indicado");
				return;
			}
            else {valor = PI/( sin(PI*num) * exp( LNGAMA(1-num) ) );}
            }
        else {valor = exp(LNGAMA(num));}
	}
	
	var E_int = (num - parseInt(num)==0)? true : false;
	if (num>0 && E_int) {
		valor = Math.round(valor);
	}
	return valor;
}

function GRAUS(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = 180*num/Math.PI;	
	return valor;
}

function HtoP(h, d, unid) {
	if (isNaN(parseFloat(h))) {FaltaArg(); return;}
	var p = 0;
	h = parseFloat(h);
	d = parseFloat(d);
	unid = parseFloat(unid);	
	if (isNaN(unid)) {unid = 0;}
	if (isNaN(d)) {d = 1;}
	if (unid==0) {
		p = 0.1 * h * d;
	}
	else if (unid==1) {
		p = 0.43353 * h * d;
	}
	if (p<0) {
		alert("O valor de P não pode ser negativo.\n\nVerifique os dados e tente novamente.");
		return;
	}	
	return p;
}

function INT(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = parseInt(num);
	return valor;
}

function LN(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<=0) {alert("O valor do argumento deve ser maior que 0"); return;}
	return Math.log(num);
}

function LOG(num, base) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<=0) {alert("O valor do argumento 1 deve ser maior que 0"); return;}
	if (base<=1) {alert("O valor do argumento 2 deve ser maior que 1"); return;}
	if (isNaN(parseFloat(base))) {base = 10;}
	var valor = Math.log(num)/Math.log(base);	
	return valor;
}

function LOG10(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<=0) {alert("O valor do argumento deve ser maior que 0"); return;}
	var valor = Math.log(num)/Math.LN10;	
	return valor;
}

function LNGAMA(num)  {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}	
	if (num<=0 && ((Math.abs(num)-Math.floor(Math.abs(num))==0) || GAMA(num)<0 )) {
		alert ("Não é possível calcular a função LNGAMA para o valor indicado");
		return;
    }	
    with(Math) {
        var a=1;
        var b=0;        
        while ( num<8 ) { a*=num; num++ }
        b=1/(num*num);
        return ((((((((-3617/122400)*b + 7/1092)*b - 691/360360)*b + 5/5940)*b - 1/1680)*b + 1/1260)*b -1/360)*b + 1/12)/num + 0.5 * log(2*PI)-log(a)-num+(num-0.5)*log(num);
	} 
}

function MAXIMO(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "maximo", 1);
}

function MEDIA(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "media", 1);
}

function MEDIAGEO(lista) {
	if (lista==null) {FaltaArg(); return;}	
	for (var i = 0; i <= lista.length - 1; i++) {				
		if (lista.charAt(i).match(/\-/)) {
			alert ("A lista de dados da função MEDIAGEO não pode conter valores negativos");
			return;
		}			
	}	
	return Estatistica(lista, "mediageo", 1);
}

function MED(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "mediana", 1);
}

function MINIMO(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "minimo", 1);
}

function MOD(num, divisor) {
	if (isNaN(parseFloat(num)) || isNaN(parseFloat(divisor))) {FaltaArg(); return;}
	if (divisor==0) {alert("O valor do argumento 2 deve ser diferente de 0"); return;}
	var valor = num % divisor;	
	return valor;
}

function MODA(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "moda", 1);	
	if (valor!="NA") {return valor;}
	else {return alert("A lista de dados não apresenta uma Moda")}
}

function NPER(taxa, pgto, vp, vf, tipo) {
	var tx_stg = taxa+"";
	var nper = 0;
	var parc1, parc2;
	taxa = parseFloat(taxa);
	pgto = parseFloat(pgto);
	vp = parseFloat(vp);
	vf = parseFloat(vf);
	tipo = parseFloat(tipo);
	if (isNaN(taxa)) {taxa = 0;}
	if (isNaN(pgto)) {pgto = 0;}
	if (isNaN(vp)) {vp = 0;}
	if (isNaN(vf)) {vf = 0;}
	if (isNaN(tipo)) {tipo = 0;}	
	if (tx_stg.indexOf("%")!=-1) {
		taxa = parseFloat(tx_stg.slice(0,tx_stg.indexOf("%")))/100;
	}	
	if (tipo!=0 && tipo!=1) {alert("O valor do argumento 5 (tipo) deve ser igual a 0 (final de período) ou igual a 1 (início de período)"); return;}
	if (pgto==0 && ((vf/vp)>=0 || isNaN(vf/vp))) {alert("Não foi possível calcular NPER.\n\nVerifique os dados e tente novamente."); return;}

    if(taxa == 0) {
        if(pgto != 0) {nper = -(vf + vp) / pgto;}
		else {alert("Não foi possível calcular NPER.\n\nVerifique os dados e tente novamente."); return;}
    } else
    {
        parc1 = -vf * taxa + pgto + taxa * pgto * tipo;
        parc2 = pgto + taxa * vp + taxa * pgto * tipo;        
		if (parc1==0 || parc2==0) {alert("Não foi possível calcular NPER.\n\nVerifique os dados e tente novamente."); return;}
		nper = Math.log(parc1 / parc2) / Math.log(1 + taxa);
    }
	return nper;
}

function NPSH(pfs, pv, d, pa, vfs, unid) {
	if (isNaN(parseFloat(pfs))) {FaltaArg(); return;}
	if (isNaN(parseFloat(pv))) {FaltaArg(); return;}
	var npsh = 0;
	var parc1 = 0;
	var parc2 = 0;	
	pfs = parseFloat(pfs);
	pv = parseFloat(pv);
	d = parseFloat(d);
	pa = parseFloat(pa);
	vfs = parseFloat(vfs);
	unid = parseFloat(unid);	
	if (isNaN(unid)) {unid = 0;}
	if (isNaN(d)) {d = 1;}
	if (isNaN(pa)) {pa = (unid==0)? 1.03323 : 14.696;}
	if (isNaN(vfs)) {vfs = 0;}
	var g = (unid==0)? 9.80665 : 32.174;	
	if (unid==0) {
		parc1 = 10 * (pfs + pa - pv) / d;	
	}
	else if (unid==1) {
		parc1 = 2.31 * (pfs + pa - pv) / d;	
	}
	if (vfs!=0) {
		parc2 = vfs * vfs / (2 * g)
	}
	npsh = parc1 + parc2;
	if (npsh<0) {
		alert("O valor do NPSH não pode ser negativo.\n\nVerifique os dados e tente novamente.");
		return;
	}	
	return npsh;
}

function NS(n, q, h) {
	if (isNaN(parseFloat(n))) {FaltaArg(); return;}
	if (isNaN(parseFloat(q))) {FaltaArg(); return;}
	if (isNaN(parseFloat(h))) {FaltaArg(); return;}
	var ns = 0;
	n = parseFloat(n);
	q = parseFloat(q);
	npshr = parseFloat(h);
	nss = n * Math.sqrt(q) / Math.pow(h, 0.75);	
	if (ns<0) {
		alert("O valor de Ns não pode ser negativo.\n\nVerifique os dados e tente novamente.");
		return;
	}	
	return nss;
}

function NSS(n, q, npshr) {
	if (isNaN(parseFloat(n))) {FaltaArg(); return;}
	if (isNaN(parseFloat(q))) {FaltaArg(); return;}
	if (isNaN(parseFloat(npshr))) {FaltaArg(); return;}
	var nss = 0;
	n = parseFloat(n);
	q = parseFloat(q);
	npshr = parseFloat(npshr);
	nss = n * Math.sqrt(q) / Math.pow(npshr, 0.75);	
	if (nss<0) {
		alert("O valor de Nss não pode ser negativo.\n\nVerifique os dados e tente novamente.");
		return;
	}	
	return nss;
}

function PERMUT(num1, num2) {
	if (isNaN(parseFloat(num1))) {FaltaArg(); return;}
	if (isNaN(parseFloat(num2))) {num2 = 0;}	
	if (num1<num2) {alert("O valor do argumento 1 deve ser maior do que o valor do argumento 2"); return;}
	if (num1<0 || num2<0) {alert("Os argumentos devem ser positivos"); return;}
	num1 = parseInt(num1);
	num2 = parseInt(num2);	
	var valor = FATORIAL(num1)/FATORIAL(num1-num2);	
	return valor;
}

function PGTO(taxa, nper, vp, vf, tipo) {
	var tx_stg = taxa+"";
	var pgto = 0;
	var expo;
	taxa = parseFloat(taxa);
	nper = parseFloat(nper);
	vp = parseFloat(vp);
	vf = parseFloat(vf);
	tipo = parseFloat(tipo);
	if (isNaN(taxa)) {taxa = 0;}
	if (isNaN(nper)) {nper = 0;}
	if (isNaN(vp)) {vp = 0;}
	if (isNaN(vf)) {vf = 0;}
	if (isNaN(tipo)) {tipo = 0;}	
	if (tx_stg.indexOf("%")!=-1) {
		taxa = parseFloat(tx_stg.slice(0,tx_stg.indexOf("%")))/100;
	}	
	if (tipo!=0 && tipo!=1) {alert("O valor do argumento 5 (tipo) deve ser igual a 0 (final de período) ou igual a 1 (início de período)"); return;}
	if(taxa == 0) {
	    if(nper != 0) {pgto = -(vf + vp) / nper;}
		else {alert("Não foi possível calcular PGTO.\n\nVerifique os dados e tente novamente."); return;}
	} else
	{
	    if ((nper != 0)) {
			expo = Math.pow(1 + taxa, nper);
		    pgto = -(taxa * (vf + expo * vp)) / ((-1 + expo) * (1 + taxa * tipo));
		}
		else {alert("Não foi possível calcular PGTO.\n\nVerifique os dados e tente novamente."); return;}
	}
	return pgto;
}

function PI() {
	return Math.PI;
}

function POISSON(num, lambda, acum) {
	if (isNaN(parseFloat(num)) || isNaN(parseFloat(lambda))) {FaltaArg(); return;}
	if (isNaN(parseFloat(acum))) {acum = 0;}
	if (num<=0) {alert("O valor do argumento 1 (x) deve ser maior do que 0"); return;}
	if (lambda<=0) {alert("O valor do argumento 2 (Lambda) deve ser maior do que 0"); return;}
	if (acum!=0 && acum!=1) {alert("O valor do argumento 3 (acumulado) deve ser igual a 0 (Falso) ou igual a 1 (Verdadeiro)"); return;}
	num = parseInt(num);
	var valor = 0;	
	if (acum==0) {
		valor = Math.exp(-1*lambda)*Math.pow(lambda, num)/FATORIAL(num);
	}	
	else if (acum==1) {
		for (var i=0; i<=num; i++) {
			valor += Math.exp(-1*lambda)*Math.pow(lambda, i)/FATORIAL(i);			
		}
	}
	return valor;
}

function POTENCIA(num, elev) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (isNaN(parseFloat(elev))) {elev = 0;}
	var valor = Math.pow(num, elev);	
	return valor;
}

function PtoH(p, d, unid) {
	if (isNaN(parseFloat(p))) {FaltaArg(); return;}
	var h = 0;
	p = parseFloat(p);
	d = parseFloat(d);
	unid = parseFloat(unid);	
	if (isNaN(unid)) {unid = 0;}
	if (isNaN(d)) {d = 1;}
	if (unid==0) {
		h = 10 * p / d;
	}
	else if (unid==1) {
		h = 2.3067 * p / d;
	}
	if (h<0) {
		alert("O valor de H não pode ser negativo.\n\nVerifique os dados e tente novamente.");
		return;
	}	
	return h;
}

function QUARTIL1(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "quartil1", 1);
	if (valor!="NA") {return valor;}
	else {return alert("Não é possível calcular o Quartil 1")}
}

function QUARTIL2(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "quartil2", 1);
}

function QUARTIL3(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "quartil3", 1);
	if (valor!="NA") {return valor;}
	else {return alert("Não é possível calcular o Quartil 3")}
}

function QUOCIENTE(num, denom) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (isNaN(parseFloat(denom))) {denom = 1;}
	if (denom==0) {alert("O valor do denominador da função QUOCIENTE deve ser diferente de 0"); return;}
	var valor = parseInt(num/denom);	
	return valor;
}

function RADIANOS(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = Math.PI*num/180;	
	return valor;
}

function RAIZ(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (num<0) {alert("O valor do argumento da função RAIZ não pode ser negativo"); return;}
	return Math.sqrt(num);
}

function SEC(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = 1/Math.cos(num);	
	return valor;
}

function SECH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = 1/COSH(num);	
	return valor;
}

function SEN(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	return Math.sin(num);
}

function SENH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = (Math.exp(num) - Math.exp(-num))/2;	
	return valor;
}

function SOMA(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "soma", 1);
}

function TAN(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	return Math.tan(num);
}

function TANH(num) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	var valor = SENH(num)/COSH(num);	
	return valor;
}

function TAXA(nper, pgto, vp, vf, tipo, estima) {
	var estima_stg = estima+"";		
    var max_intera = 200;
    var val = 0;
    var val_ant = 0;
    var delta = 0;
    var delta_ant = 0;	
	nper = parseFloat(nper);
	pgto = parseFloat(pgto);
	vp = parseFloat(vp);
	vf = parseFloat(vf);
	tipo = parseFloat(tipo);
	if (estima_stg.indexOf("%")!=-1) {
		estima = parseFloat(estima_stg.slice(0,estima_stg.indexOf("%")))/100;
	}
	if (isNaN(nper)) {FaltaArg(); return;}
	if (isNaN(pgto) && isNaN(vp) && isNaN(vf)) {FaltaArg(); return;}
	if (isNaN(pgto)) {pgto = 0;}
	if (isNaN(vp)) {vp = 0;}
	if (isNaN(vf)) {vf = 0;}
	if (isNaN(tipo)) {tipo = 0;}
	if (tipo!=0 && tipo!=1) {alert("O valor do argumento 5 (tipo) deve ser igual a 0 (final de período) ou igual a 1 (início de período)"); return;}
	if (isNaN(estima) || estima=='') {estima = 0.05;}	
    var tx = estima;
	if(vp == 0 && vf == 0) {
        alert("Não foi possível calcular TAXA.\n\nVerifique os dados e tente novamente.");
		return;
    }
	else {
        var i = 0;
        var j = 0;
        var tentativa = tx;
        var td = tentativa * 0.5;
        if(td == 0) {td = 1;}
        do {
            tentativa += td;
            if(tentativa != 0) {
                val = VF(tentativa, nper, pgto, vp, tipo);
                delta = Math.abs(val - vf);
            }
            if(i > 0) {
                j++;
                if(Math.abs(val - val_ant) > 0.0001 || delta > 0.0001) {j = 0;}
                if(delta > delta_ant) {td *= -0.5;}
            }
            val_ant = val;
            delta_ant = delta;
        }
		while(i++ < max_intera && j < 3);
        if(i < max_intera) {tx = tentativa;}
        else {
			alert("Não foi possível calcular TAXA.\n\nVerifique os dados e tente novamente.");
			return;		
		}
    }
	return tx;
}

function TIR(fluxo) {
	if (fluxo==null) {FaltaArg(); return;}
	var listDados = fluxo.slice(1,fluxo.length-1);
	var valor = 0;
	var PREC = 1.0e-5;
	var MAX_INT = 50;
	var tx1 = 0;
	var tx2 = 0.2;
	var MSG_ERRO = "Não foi possível calcular a TIR.\n\nVerifique o fluxo de caixa e tente novamente.";
	var f1 = VPL(fluxo, tx1);	
	if (f1=="NA") {return;}	
	var f2 = VPL(fluxo, tx2);
		
	for (var i=0; i<MAX_INT; i++) {
		if ((f1*f2) < 0.0) {break;}
		if (Math.abs(f1)<Math.abs(f2)) {f1 = VPL(fluxo, tx1+=1.6*(tx1-tx2));}
		else {f2 = VPL(fluxo, tx2+=1.6*(tx2-tx1));}
	}
	
	if ((f1*f2)>0) {alert(MSG_ERRO); return;}
	var f = VPL(fluxo, tx1);
	var txb = 0;
	var dtx = 0;
	var txi = 0;
	var fi = 0;
	if (f<0) {txb = tx1; dtx = tx2-tx1;}
	else {txb = tx2; dtx = tx1-tx2;}
	
	for (var i=0; i<MAX_INT; i++) {
		dtx *= 0.5;
		txi = txb+dtx;
		fi = VPL(fluxo, txi);
		if (fi<=0.0) {txb = txi;}
		if ((Math.abs(fi)<PREC) || (Math.abs(dtx)<PREC)) return txi;		
	}
	alert(MSG_ERRO);	
	return;
}

function VAR(lista) {
	if (lista==null) {FaltaArg(); return;}
	var valor = Estatistica(lista, "variancia", 1);
	if (valor!="NA") {return valor;}
	else {return alert("Não é possível calcular a Variância")}
}

function VARP(lista) {
	if (lista==null) {FaltaArg(); return;}
	return Estatistica(lista, "variancia", 2);
}

function VF(taxa, nper, pgto, vp, tipo) {
	var tx_stg = taxa+"";
	var vf = 0;
	var expo;
	taxa = parseFloat(taxa);
	nper = parseFloat(nper);
	pgto = parseFloat(pgto);
	vp = parseFloat(vp);
	tipo = parseFloat(tipo);
	if (isNaN(taxa)) {taxa = 0;}
	if (isNaN(nper)) {nper = 0;}
	if (isNaN(pgto)) {pgto = 0;}
	if (isNaN(vp)) {vp = 0;}
	if (isNaN(tipo)) {tipo = 0;}	
	if (tx_stg.indexOf("%")!=-1) {
		taxa = parseFloat(tx_stg.slice(0,tx_stg.indexOf("%")))/100;
	}	
	if (tipo!=0 && tipo!=1) {alert("O valor do argumento 5 (tipo) deve ser igual a 0 (final de período) ou igual a 1 (início de período)"); return;}

	if(taxa == 0) {
	    vf = -nper * pgto - vp;
	} else
	{
	    var q = Math.pow(1 + taxa, nper);
	    vf = -q * vp - ((-1 + q) * pgto * (1 + taxa * tipo)) / taxa;
	}
	return vf;
}

function VP(taxa, nper, pgto, vf, tipo) {
	var tx_stg = taxa+"";
	var vp = 0;
	var expo, expo1;
	taxa = parseFloat(taxa);
	nper = parseFloat(nper);
	pgto = parseFloat(pgto);
	vf = parseFloat(vf);
	tipo = parseFloat(tipo);
	if (isNaN(taxa)) {taxa = 0;}
	if (isNaN(nper)) {nper = 0;}
	if (isNaN(pgto)) {pgto = 0;}
	if (isNaN(vf)) {vf = 0;}
	if (isNaN(tipo)) {tipo = 0;}	
	if (tx_stg.indexOf("%")!=-1) {
		taxa = parseFloat(tx_stg.slice(0,tx_stg.indexOf("%")))/100;
	}	
	if (tipo!=0 && tipo!=1) {alert("O valor do argumento 5 (tipo) deve ser igual a 0 (final de período) ou igual a 1 (início de período)"); return;}

	if(taxa == 0) {
	    vp = -vf - nper * pgto;
	} else
	{
	    expo1 = Math.pow(1 + taxa, -nper);
	    expo2 = Math.pow(1 + taxa, nper);
	    vp = -expo1 * (vf + ((-1 + expo2) * pgto * (1 + taxa * tipo)) / taxa);
	}
	return vp;
}

function VPL(fluxo, taxa) {
	if (fluxo==null || taxa==null) {FaltaArg(); return;}
	var listDados = fluxo.slice(1,fluxo.length-1);
	var valor = 0;
	var tx = parseFloat(taxa);
	var tx_stg = taxa+"";
	if (tx_stg.indexOf("%")!=-1) {
		tx = parseFloat(tx_stg.slice(0,tx_stg.indexOf("%")))/100;	
	}	
	if (isNaN(tx)) {
		alert("A Taxa não é um valor válido");
		return;
	}	
	MatrizDados(listDados, "NA");
	for (var i = 0; i < MatDados1.length; i++) {
		valor += MatDados1[i]/Math.pow(1+tx, i);
	}
	return (!isNaN(MatDados1[0]))? valor : "NA";
}

function WEIBULL(num, beta, eta, acum) {
	if (isNaN(parseFloat(num))) {FaltaArg(); return;}
	if (isNaN(parseFloat(acum))) {acum = 0;}
	if (num<0) {alert("O valor do argumento 1 (x) deve ser maior ou igual a 0"); return;}
	if (beta<=0  || eta<=0) {alert("beta e eta devem ser maiores do que 0"); return;}
	if (acum!=0 && acum!=1) {alert("O valor do argumento 4 (acumulado) deve ser igual a 0 (Falso) ou igual a 1 (Verdadeiro)"); return;}
	var valor = 0;	
	if (acum==0) {
		valor = beta*Math.pow(num, beta-1)*Math.exp(-1*(Math.pow(num/eta, beta)))/Math.pow(eta, beta);
	}
	else if (acum==1) {
		valor = 1-Math.exp(-1*(Math.pow(num/eta, beta)));
	}
	return valor;
}
//Fim de Funções Especiais


//Funções Estatísticas
if (!window.opener) {
	var obj_window2 = window;
}
else {
	var obj_window2 = window.opener;
}
var MatDados1, MatDados2;
var Lista1 = obj_window2.parent.frames['frame_menu'].Lista1;
var Lista2 = obj_window2.parent.frames['frame_menu'].Lista2;
function MatrizDados(str_observ1, str_observ2) {
	var str_valor = "";
	var j = 0;
	var delimit = true;
	
	MatDados1 = new Array(1);
	if (str_observ1!="lista1" && str_observ1!="lista2") {
		for (var i = 0; i <= str_observ1.length - 1; i++) {  
			if ((str_observ1.charAt(i)).match(/[\-\d\.\,]/)) {
			str_valor += str_observ1.charAt(i);
			delimit = false;
			}
			else if ((str_observ1.charAt(i)).match(/\s/)) {
				if (!(str_observ1.charAt(i)).match(/\n/)) {
					continue;
				}
			}		
			else if (!(str_observ1.charAt(i)).match(/[\;\:]/)) {
			alert ("A 'Lista de Observações' apresenta caracteres inválidos.\nVerifique os dados e os separadores e tente novamente");
			return false;
			}
			
			if ((str_observ1.charAt(i)).match(/[\;\:\n]/) || (i == str_observ1.length-1)) {			
				if (delimit) {continue;}
				if (isNaN(str_valor)){
					str_valor = str_valor.replace(/,/, ".");
				}			
				MatDados1.length = j+1;
				if (!isNaN(parseFloat(str_valor))) {
					MatDados1[j] = parseFloat(str_valor);
				}
				else {
					str_valor = "";
					continue;
				}
				j++;
				str_valor = "";
				delimit = true;					
			}
		}
	}
	else {
		if (str_observ1=="lista1") {
			for (var i = 0; i < Lista1.length; i++) {
				MatDados1[i] = Lista1[i];
			}		
		}
		else {
			for (var i = 0; i < Lista2.length; i++) {
				MatDados1[i] = Lista2[i];
			}
		}
				
		if (MatDados1[0]==null) {
			var mens_Text1 = (str_observ1=="lista1")? "Lista 1" : "Lista 2";
			alert("A "+ mens_Text1 + " está vazia");
			return false;
		}
	}

	if (str_observ2!="NA") {	
		str_valor = "";
		j = 0;	
		delimit = true;
		
		MatDados2 = new Array(1);	
		if (str_observ2!="lista1" && str_observ2!="lista2") {
			for (var i = 0; i <= str_observ2.length - 1; i++) {  
				if ((str_observ2.charAt(i)).match(/[\-\d\.\,]/)) {
				str_valor += str_observ2.charAt(i);
				delimit = false;
				}
				else if ((str_observ2.charAt(i)).match(/\s/)) {
					if (!(str_observ2.charAt(i)).match(/\n/)) {
						continue;
					}
				}		
				else if (!(str_observ2.charAt(i)).match(/[\;\:]/)) {
				alert ("A 'Lista de Observações' apresenta caracteres inválidos.\nVerifique os dados e os separadores e tente novamente");
				return false;
				}
				
				if ((str_observ2.charAt(i)).match(/[\;\:\n]/) || (i == str_observ2.length-1)) {			
					if (delimit) {continue;}
					if (isNaN(str_valor)){
						str_valor = str_valor.replace(/,/, ".");
					}			
					MatDados2.length = j+1;
					if (!isNaN(parseFloat(str_valor))) {
						MatDados2[j] = parseFloat(str_valor);
					}
					else {
						str_valor = "";
						continue;
					}
					j++;
					str_valor = "";
					delimit = true;					
				}
			}
		}
		else {
			if (str_observ2=="lista1") {
				for (var i = 0; i < Lista1.length; i++) {
					MatDados2[i] = Lista1[i];
				}		
			}
			else {
				for (var i = 0; i < Lista2.length; i++) {
					MatDados2[i] = Lista2[i];
				}
			}			
			
			if (MatDados2[0]==null) {
				var mens_Text2 = (str_observ2=="lista1")? "Lista 1" : "Lista 2";
				alert("A "+ mens_Text2 + " está vazia");
				return false;
			}
		}	
	}	
}

function Estatistica(str_txt, medida, opv) {	
	
	if (str_txt.charAt(0)!="[" || str_txt.charAt(str_txt.length-1)!="]") {
		alert ("A sintaxe da função está errada.\n\n Sintaxe correta:  "+medida.toUpperCase()+"\(\"[Lista de Dados]\"\)");	
		return;
	}
	
	var observ = str_txt.slice(1,str_txt.length-1);
	var opvar = opv;
	var cont = 0;
	var cont_ant = 0;
	var mod = 0;
	var soma = 0;
	var mult = 1;
	var contagem = 0;
	var media = 0;
	var mediageo = 0;
	var mediana = 0;
	var moda = 0;
	var desv_pad = 0;
	var variancia = 0;
	var minimo = 0;
	var maximo = 0;
	var amp = 0;
	var erro_pad = 0;
	var cv = 0;
	var curt = 0;
	var curtose = 0;
	var assimet = 0;
	var assimetria = 0;
	var n_quart = 0;
	var ind_q1 = 0;
	var ind_q3 = 0;
	var quartil1 = 0;
	var quartil3 = 0;
	
	MatrizDados(observ, "NA");

	function compareNumbers(a, b) {return a - b}		
	MatDados1.sort(compareNumbers);	
	for (var i = 0; i <= MatDados1.length - 1; i++) {
		soma += MatDados1[i];
		mult *= MatDados1[i];
		mod = MatDados1[i];
		cont = 0;
		
		for (var j = i+1; j <= MatDados1.length - 1; j++) {
			if(mod==MatDados1[j]){cont++;}
		}
		
		if(cont > cont_ant) {
			moda = mod;
			cont_ant = cont;
		}			
	}	
	
	//Calcula Valores
	contagem = MatDados1.length;
	media = soma/contagem;
	mediageo = Math.pow(mult, 1/contagem);
	
	if ((MatDados1.length)%2==0) {  //Mediana e Quartis
		mediana = (MatDados1[MatDados1.length/2] + MatDados1[(MatDados1.length/2)-1])/2;
		n_quart = MatDados1.length/2;			
		if (n_quart%2==0) {   //Quartis				
			ind_q1 = n_quart/2;
			ind_q3 = parseInt((MatDados1.length+n_quart)/2);				
			quartil1 = (((MatDados1[ind_q1] + MatDados1[ind_q1-1])/2) + (MatDados1[ind_q1]))/2;
			quartil3 = (((MatDados1[ind_q3] + MatDados1[ind_q3-1])/2) + (MatDados1[ind_q3-1]))/2;				
		}
		else {				
			ind_q1 = parseInt(n_quart/2);
			ind_q3 = parseInt((MatDados1.length+n_quart)/2);
			quartil1 = (((MatDados1[ind_q1] + MatDados1[ind_q1+1])/2) + (MatDados1[ind_q1]))/2;
			quartil3 = (((MatDados1[ind_q3] + MatDados1[ind_q3+1])/2) + (MatDados1[ind_q3-1]))/2;
		}
	}
	else {
		var ind_med = parseInt(MatDados1.length/2);
		mediana = MatDados1[ind_med];
		n_quart = ind_med + 1;
		if (n_quart%2==0) {   //Quartis		
			ind_q1 = n_quart/2;
			ind_q3 = parseInt((MatDados1.length+n_quart-1)/2);
			quartil1 = (MatDados1[ind_q1] + MatDados1[ind_q1-1])/2;
			quartil3 = (MatDados1[ind_q3] + MatDados1[ind_q3-1])/2;
		}
		else {
			ind_q1 = parseInt(n_quart/2);
			ind_q3 = parseInt((MatDados1.length+n_quart-1)/2);
			quartil1 = MatDados1[ind_q1];
			quartil3 = MatDados1[ind_q3];
		}
	}
		
	if(cont_ant == 0) {
		moda = "NA"
	}
	
	for (var k = 0; k <= MatDados1.length - 1; k++) {
		variancia += (MatDados1[k]-media) * (MatDados1[k]-media);
	}
	variancia = (opvar==1)? variancia/(contagem-1) : variancia/contagem;
	desv_pad = Math.sqrt(variancia);
	minimo = MatDados1[0];
	maximo = MatDados1[MatDados1.length-1];
	amp = maximo - minimo;
	erro_pad = desv_pad/Math.sqrt(contagem);
	cv = desv_pad/media;
	
	for (var p = 0; p <= MatDados1.length - 1; p++) {
		assimet += ((MatDados1[p]-media)/desv_pad) * ((MatDados1[p]-media)/desv_pad) * ((MatDados1[p]-media)/desv_pad);
		curt += ((MatDados1[p]-media)/desv_pad) * ((MatDados1[p]-media)/desv_pad) * ((MatDados1[p]-media)/desv_pad) * ((MatDados1[p]-media)/desv_pad);
	}
	
	assimetria = ((contagem*assimet)/((contagem-1)*(contagem-2)));
	curtose = ((contagem*(contagem+1)*curt)/((contagem-1)*(contagem-2)*(contagem-3)))-((3*(contagem-1)*(contagem-1))/((contagem-2)*(contagem-3)));	
	
	switch (medida) {
		case "media" :
			return media;		
		break;
		case "mediageo" :
			return mediageo;		
		break;
		case "mediana" :
			return mediana;		
		break;
		case "moda" :
			return moda;		
		break;
		case "desv_pad" :
			return (!isNaN(desv_pad))? desv_pad : "NA";		
		break;
		case "variancia" :
			return (!isNaN(variancia))? variancia : "NA";		
		break;
		case "minimo" :
			return minimo;		
		break;
		case "maximo" :
			return maximo;		
		break;
		case "amp" :
			return amp;		
		break;		
		case "erro_pad" :
			return (!isNaN(erro_pad))? erro_pad : "NA";		
		break;		
		case "cv" :
			return (!isNaN(cv))? cv : "NA";		
		break;		
		case "assimetria" :
			return (!isNaN(assimetria))? assimetria : "NA";		
		break;		
		case "curtose" :
			return (!isNaN(curtose))? curtose : "NA";		
		break;		
		case "soma" :
			return soma;		
		break;		
		case "contagem" :
			return contagem;		
		break;		
		case "quartil1" :
			return (!isNaN(quartil1))? quartil1 : "NA";		
		break;		
		case "quartil2" :
			return mediana;	
		break;		
		case "quartil3" :
			return (!isNaN(quartil3))? quartil3 : "NA";		
		break;		

	}
}
//Fim de Funções Estatísticas


//Funções Auxiliares para Integração
function _DistNormP(x) {
	var valor = Math.exp((-1*x*x/2))/Math.sqrt(2*Math.PI);
	return valor;
}

var _alfa, _beta;
function _DistGama(x) {
	var valor = (Math.pow(x,(_alfa-1))*Math.exp(-1*x/_beta))/(Math.pow(_beta,_alfa)*GAMA(_alfa));
	return valor;
}


var _graus_lib;
function _DistT(x) {
	var valor = GAMA((_graus_lib+1)/2)/(GAMA(_graus_lib/2)*Math.sqrt(_graus_lib*Math.PI)*Math.pow((1+x*x/_graus_lib),(_graus_lib+1)/2));
	return valor;
}

function _DistQUI(x) {
	var valor = Math.pow(x, (_graus_lib/2)-1)*Math.exp(-1*x/2)/(Math.pow(2, _graus_lib/2)*GAMA(_graus_lib/2));
	return valor;
}


//------------------------------------------------------------
//Pendente!!!!!!
//- Acrescentar função INTEGRAL()
//- Outras funções de probabilidade importantes (qWeibull, qNormal,........???)
//- Funções de Bessel
//- Verificação de "," em funções (permitir "," apenas na separação de argumentos)
//- Operador "^" e "!"
//------------------------------------------------------------