Jump to content
barras

Problema com cálculo

Recommended Posts

barras

public class EstudoPermeabilidade{  
   private int iteracoes;  
        private int dimensao;  
        private int numPontos;  
        private double p;  
   private double y;  
  
  
   /** 
   * Constroi o estudo da permeabilidade 
   * @requires int dimensao>0 && numPontos>2 && iteracoes>0 
   * 
   */  
   public EstudoPermeabilidade(int dimensao, int numPontos, int iteracoes){  
              
                  
      dimensao();  
      pontos();  
      iteracoes();  
                  
  
        }  
        /** 
   * @return tamanho da dimensao 
   */  
   public int dimensao(){  
           this.dimensao = dimensao;  
      return dimensao;  
   }  
   /** 
   * @return numero de pontos de estudo 
   */  
   public int pontos(){  
           this.numPontos = numPontos;  
      return numPontos;  
           }  
   /** 
   * @return numero de sistemas criados para cada ponto do estudo 
   */  
   public int iteracoes(){  
           this.iteracoes = iteracoes;  
      return iteracoes;  
   }  
   /** 
   * @return a abcissa do i-esimo ponto 
   * @requires i>=0 && i<pontos() 
   */  
   public double pPonto(int i){  
            p = i/(numPontos-1);  
                  
                          
            return p;  
   }  
   /** 
   * @return a ordenada do i-esimo ponto 
   * @requires i>=0 && i<pontos() 
   */  
   public double yPonto(int i){  
            y = i/pPonto();  
                      
            return y;  
   }  
   /** 
   * @return o ponto de transicao da probabilidade do sistema ser permeavel 
   */  
   public double pontoTransicao(){  
      while(y < 0.5){  
         y++;  
      }  
      return p;  
   }  
}  

Por que razão é que ele não me faz a conta certa e dá sempre 0.0 no pPonto() e no yPonto()? Ajudem-me lá pessoal, só me falta conseguir fazer as contas correctamente para acabar esta classe.  :)

Share this post


Link to post
Share on other sites
daj

Nunca afectas numPontos, ou melhor, afectas com o valor que já lá estava:

this.numPontos = numPontos; 

Se leio bem o código, parece-me é que pPonto(i) devolve -i e yPonto(i) devolve -1.

Share this post


Link to post
Share on other sites
barras

Mas eu quero é o numPontos que vai ser introduzido no construtor EstudoPermeabilidade para dividir com o i. O problema é mesmo o numPontos, porque o i ele já está a assumir bem.

Share this post


Link to post
Share on other sites
daj

Então tens que afectar no construtor o this.numPontos com o argumento numPontos. Ou então passas o numPontos à função pontos().

public EstudoPermeabilidade(int dimensao, int numPontos, int iteracoes){        
...
  pontos(numPontos);  
...
}  

public int pontos(int numPontos) {  
  this.numPontos = numPontos;  
  return numPontos;  
}

Edit: Já agora, tens problemas semelhantes para this.iteracoes e this.dimensao. Por outras palavras, o código que tens no construtor (as 3 invocações de funções) não faz nada de útil e poderia ser removido.

Share this post


Link to post
Share on other sites
barras
*** TESTE --- ESTUDO DE PERMEABILIDADE ****

Estudo com sistemas de dimensao 100

usando 50 pontos e 100 iteracoes

Resultados do Estudo

p=0.0, y=NaN

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=0.0, y=Infinity

p=1.0, y=49.0

Isto é o que me dá...

Estudo com sistemas de dimensao 100 usando 50 pontos e 100 iteracoes

Resultados do Estudo

p=0.0, y=0.0

p=0.02040816326530612, y=0.0

p=0.04081632653061224, y=0.0

p=0.061224489795918366, y=0.0

p=0.08163265306122448, y=0.0

p=0.1020408163265306, y=0.0

p=0.12244897959183673, y=0.0

p=0.14285714285714285, y=0.0

p=0.16326530612244897, y=0.0

p=0.18367346938775508, y=0.0

p=0.2040816326530612, y=0.0

p=0.22448979591836732, y=0.0

p=0.24489795918367346, y=0.0

p=0.26530612244897955, y=0.0

p=0.2857142857142857, y=0.0

p=0.3061224489795918, y=0.0

p=0.32653061224489793, y=0.0

p=0.3469387755102041, y=0.0

p=0.36734693877551017, y=0.0

p=0.3877551020408163, y=0.0

p=0.4081632653061224, y=0.0

p=0.42857142857142855, y=0.0

p=0.44897959183673464, y=0.0

p=0.4693877551020408, y=0.0

p=0.4897959183673469, y=0.0

p=0.5102040816326531, y=0.0

p=0.5306122448979591, y=0.0

p=0.5510204081632653, y=0.0

p=0.5714285714285714, y=0.08

p=0.5918367346938775, y=0.45

p=0.6122448979591836, y=0.95

p=0.6326530612244897, y=0.99

p=0.6530612244897959, y=1.0

p=0.673469387755102, y=1.0

p=0.6938775510204082, y=1.0

p=0.7142857142857142, y=1.0

p=0.7346938775510203, y=1.0

p=0.7551020408163265, y=1.0

p=0.7755102040816326, y=1.0

p=0.7959183673469387, y=1.0

p=0.8163265306122448, y=1.0

p=0.836734693877551, y=1.0

p=0.8571428571428571, y=1.0

p=0.8775510204081632, y=1.0

p=0.8979591836734693, y=1.0

p=0.9183673469387754, y=1.0

p=0.9387755102040816, y=1.0

p=0.9591836734693877, y=1.0

p=0.9795918367346939, y=1.0

p=0.9999999999999999, y=1.0

Ponto de transicao:0.5938775510204080

Isto é o que devia dar. Já apliquei a tua hipótese e ficou o resultado de cima, só com 0.0.

Share this post


Link to post
Share on other sites
daj

E com que código geras essa lista? O código que apresentaste não faz muito sentido, por isso provavelmente terás outros bugs. Por exemplo, aquele while em pontoTransicao() não faz muito sentido, porque nunca lês o valor de y depois do while. Só lês y no yPonto(), mas alteras o valor primeiro.

Share this post


Link to post
Share on other sites
barras

Eu vou postar aqui o outro código (que não fui eu quem fez mas sim a professora). O objectivo é fazer esta classe de modo a outras classes poderem utilizar as suas funções... O problema é que não está a dar bem. O pontoTransicao() já estava à espera que não estivesse bem, até porque preciso do pPonto() e do yPonto() para saber o valor a retornar.

/**
* Esta classe serve para testar o trabalho 3 de IP.
* O teste consiste 
* 1) na geracao de um sistema e observacao das suas propriedades
* 2) na criacao de um estudo de permeablidade e observacao das conclusoes
* @author antonialopes
* @date 1 Dec 2010
*
*/
public class TesteTrab3 {

public static void main(String[] args){
	testeSistema();
	testeEstudoPermeabilidade();
}


/**
 * Este procedimento procede a testes simples
	 * da classe Sistema: geracao de um sistema aleatoriamente
 * e observacao das suas varias propriedades
 */
private static void testeSistema() {

	System.out.println("*** TESTE --- GERACAO ALEATORIA DE UM " +
			"SISTEMA E PERMEABILIDADE****\n");

	// valores do teste -- podem ser mudados...
	int dimensao = 5;
	double p = 0.3;

	System.out.println("Sistema com " +dimensao+" nos e probabilidade no aberto p="+p);

	Sistema sys = new Sistema(p,dimensao);

	System.out.println("O sistema gerado:");
	System.out.print(sys);

	System.out.print("Permeavel?");
	System.out.println(sys.permeavel());
}


/**
 * Este procedimento testa a cria��o de um estudo de permeabilidade
 * e observacao das suas propriedades
 */
private static void testeEstudoPermeabilidade() {
	System.out.println("*** TESTE --- ESTUDO DE PERMEABILIDADE ****\n");

	// valores do teste -- podem ser mudados...
	int dimensao = 100;
	int pontos = 50;
	int iteracoes = 100;

	System.out.println("Estudo com sistemas de dimensao " +dimensao);
	System.out.println("usando "+pontos+" pontos e "+iteracoes+" iteracoes");

	EstudoPermeabilidade estudo = new EstudoPermeabilidade(dimensao,pontos,iteracoes);

	System.out.println("Resultados do Estudo\n");
	for (int i=0; i < pontos; i++){
		System.out.println("p="+estudo.pPonto(i)+", y="+estudo.yPonto(i));
	}

	System.out.println("\n\tPonto de transicao:" + estudo.pontoTransicao());
}
}

Share this post


Link to post
Share on other sites
daj

Em

p = i/(numPontos-1);

i é um int, numPontos é um int e (numPontos-1) é um int. Isso significa que a divisão é entre 2 ints e o resultado será um int. Para i == 1 e numPontos == 50, 1/49 será 0.

Experimenta mudar o código para

p = (i*1.0)/(numPontos-1);

ou para

p = (double)i/(numPontos-1);

Para que um dos operandos da divisão seja um double e assim o resultado da divisão ser um double também.

Share this post


Link to post
Share on other sites
barras

:cheesygrin: O problema do pPonto ficou resolvido. Agora tenho uma pergunta, como vou conseguir o yPonto através do pPonto?  😳 BTW, agora que olho para a resolução do pPonto, até me sinto envergonhado

Share this post


Link to post
Share on other sites
daj

Isso depende da definição de yPonto(i) que tiveres no teu enunciado, que não me parece ser a mesma que a que codificaste, já que

y == i / pPonto(i) == i / (i / numPontos - 1) == (i * (numPontos - 1)) / i == numPontos - 1

ou seja, yPontos(i) é sempre numPontos - 1 com a excepção de i == 0 em que ficas com uma divisão 0/0.

Share this post


Link to post
Share on other sites
barras

Sim, a minha fórmula está errada, mas a maneira como é explicada a obtenção do y é tão confusa que eu perco-me no meio de tanta curva. Passo a citar:

Os pontos de um estudo de permeabilidade são calculados através da geração aleatória de vários

sistemas, todos com a mesma dimensão, mas usando diferentes valores p para a probabilidade de um

nó ser aberto. A cada valor p escolhido para o estudo corresponde um ponto (p,y). O valor y é obtido

gerando vários sistemas com a probabilidade p de um nó ser aberto e determinando qual a

percentagem destes que são permeáveis. Desta forma, y é uma estimativa para a probabilidade que um

sistema, com probabilidade p de ter um nó aberto, tem de ser permeável.

Os valores das probabilidades usadas no estudo são

{0, 1/(numPontos-1), 2/(numPontos-1),..., 1}.

Share this post


Link to post
Share on other sites
daj

Então, pelo que parece por

Sistema sys = new Sistema(p, dimensao);

tens com Sistema a possibilidade de fazer essa estimativa de probabilidade y. Talvez até seja o valor devolvido pela função permeavel(). Se assim for, "Sistema" não foi um nome muito bem escolhido, porque não representa um sistema mas sim um "[conjunto de] sistemas [, com dimensao elementos, ] com a probabilidade p de um nó ser aberto e determinando qual a percentagem destes que são permeáveis."

Share this post


Link to post
Share on other sites
barras

Mas a função permeavel() não vai retornar nenhum valor, apenas true ou false... O que me faz confusão mesmo é que não dão forma de calcular o y e dizem só que as probabilidades são calculadas através daquela fórmula.

Share this post


Link to post
Share on other sites
daj

Então talvez tenhas que criar dimensao instâncias de Sistema e contabilizar a percentagem dos que permeavel() dá true. Mas isto sou eu a divagar com base nas mensagens anteriores. Tens que ir tirar dúvidas relativamente ao enunciado e só depois começar a implementação.

Share this post


Link to post
Share on other sites
barras

Pois, mas neste momento não tenho tempo para tirar dúvidas de enunciado porque é para entregar hoje até às 23h.

Se isto ajudar a perceber o enunciado... Eu estou habituado a pensar matematicamente e matematicamente temos outras formas de encontrar um ponto, nem que seja por uma função.

A classe deve oferecer as seguintes funcionalidades:

o construtor EstudoPermeabilidade(int dimensao, int numPontos, int

iteracoes) que, assumindo que dimensao>0 && numPontos>2 && iteracoes>0, constrói

um estudo de permeabilidade, onde:

 dimensao determina a dimensão dos sistemas gerados no estudo

 iteracoes determina o número de sistemas que são gerados para cada probabilidade

p de forma a encontrar o valor do y

 numPontos indica o número de pontos do estudo.

 Os valores das probabilidades usadas no estudo são

{0, 1/(numPontos-1), 2/(numPontos-1),..., 1}.

o int dimensao() que dá a dimensão dos sistemas estudados

o int pontos() que dá o número de pontos do estudo

o int iteracoes() que dá o número de sistemas gerados para cada ponto do estudo

o double pPonto(int i) que dá a abcissa do i-ésimo ponto, assumindo que i>=0 && i<

pontos()

o double yPonto(int i) que dá a ordenada do i-ésimo ponto, assumindo que i>=0 && i<

pontos()

y: probabilidade

do sistema ser

permeável

p: probabilidade de um nó ser aberto

o double pontoTransicao() que dá uma estimativa para o ponto de transição, i.e., a

probabilidade de um nó ser aberto que corresponde a uma probabilidade de o sistema ser

permeável de 0.5 (na figura, o ponto de transição é 0.593).

Share this post


Link to post
Share on other sites
daj

Então, provavelmente já tens informação de como implementar o yPonto:

iteracoes determina o número de sistemas que são gerados para cada probabilidade

p de forma a encontrar o valor do y

Então talvez tenhas que criar dimensao instâncias de Sistema e contabilizar a percentagem dos que permeavel() dá true.
(afinal parece ser iteracoes instâncias e não dimensao instâncias).

Crias várias instâncias de Sistema e para cada uma vês se é permeavel(). Contas as que são. y deverá ser a divisão entre as que são permeáveis e a totalidade das instâncias criadas.

Share this post


Link to post
Share on other sites
barras

O trabalho já foi entregue, sem o yPonto e o Transicao feitos de maneira correcta. Obrigado pela ajuda, tiveste bastante paciência.  :)

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.