Numero racional usando inteiro

Ola novamente, agora um nooovo probleminha
a prof quer que faca um prog que pege o numerador , denominador e faca as continhas normais.
soma multiplica subtrai… essas coisinhas
ate ai blz
so que ela quer que imprima o resultado com o /

o meu prog ate agora esta assim

[code]public class Racional {

private double soma, subtrai, multiplica, divide, op;
public Racional(){}

public void setSomaRacional(int n1, int n2, int d1, int d2){
	soma = (n1*d2)+ (n2*d1)/(d1*d2);
}
public void setSubtraiRacional(int n1, int n2, int d1, int d2){
	subtrai = (n1*d2)- (n2*d1)/(d1*d2);
}
public void setMultiplicaRacional(int n1, int n2, int d1, int d2){
	multiplica = ((n1*n2)/ (d1*d2));
}
public void setDivideRacional(int n1, int n2, int d1, int d2){
	divide = ((n1*d2)/(n2*d1));
}

public double getSomaRacional(){
	return soma;
}
public double getSubtraiRacional(){
	return subtrai;
}
public double getMultiplicaRacional(){
	return multiplica;
}
public double getDiviteRacional(){
	return divide;
}

}[/code]

falta fazer o toString… que nao sei como vou fazer
e mostrar na tela o doable como se fosse um int em cima do outro
:roll:
que foi justamente onde travei…
o prog vai ser rodado em outra classe…
que ainda nao terminei…
mas essa dai eh que eh a que travei =(

Boa noite colegas !

juliana:

Desculpe, mas não entendi o que vc quer que saia na tela… da pra mostrar um exemplo de entradas e saidas esperadas ?

[]s

por exemplo eu digito,…
1, 2 , 3, 2
dai o racional eh 1/2 e 3/2… dai pra soma… o resultado imprima 4/2

Boa noite colegas !

Meu raciocinio esta certo ?

n1 = 1
n2 = 2
d1 = 3
d2 = 2

soma = (n1d2)+ (n2d1)/(d1*d2);

soma = (1 * 2) + (2 * 3) / (3 * 2)

soma = (2) + (6)/(6)

soma = 3

[]s

Boa noite…
Acho que é para fazer operações matemáticas e mostrar em forma de fração não é?
1/2 + 3/2 = 4/2 (ou 2)

Creio que para fazer isso, vc vai ter que criar outros métodos para fazer o mínimo múltiplo comum dos denominadores algo assim.

n1 = 1
n2 = 3
d1 = 2
d2 = 2
(n1 + n2)/(calculaMMC(2,2))

Boa noite colegas !

kairy
Você não concorda que se a for pra somar duas frações a fórmula que ela colocou:

public void setSomaRacional(int n1, int n2, int d1, int d2){   
        soma = (n1*d2)+ (n2*d1)/(d1*d2);   
    }

estaria errada ?

[quote=Zeed01]Boa noite colegas !

kairy
Você não concorda que se a for pra somar duas frações a fórmula que ela colocou:

public void setSomaRacional(int n1, int n2, int d1, int d2){   
        soma = (n1*d2)+ (n2*d1)/(d1*d2);   
    }

estaria errada ?

[/quote]

Olá zeed, o dela está correto também, só dei algumas idéias… mas o exemplo do raciocínio que vc deu creio que esteja errado, os numeradores são os números de cima (1 e 3)

Boa noite colegas !

kairy:

Não entendi o que você quis dizer…
Veja bem o metodo que ela postou é:

public void setSomaRacional(int n1, int n2, int d1, int d2){   
        soma = (n1*d2)+ (n2*d1)/(d1*d2);   
    } 

ou seja, entram 4 números e faz-se algumas operações com estes números…
se entrando 1,2,3,2 nessa sequencia a intenção era somar as frações 1/2 e 3/2
a fórmula teria que ser:

public void setSomaRacional(int n1, int d1, int n2, int d2){   
        soma = (n1/d1) + (n2/d2)
        //substituindo teriamos soma = (1/2) + (3/2)

    } 

O que você quis dizer com “os numeradores seriam os numeros de cima (1 e 3)”.
De qualquer forma entendo que na fórmuma esta faltando parenteses para que faça primeiro a soma das multiplicações…

Por favor não interprete mal… só não entendi.

[]s

Não é pra usar double no seu programa. Estude o programa abaixo e o complete.

class Racional {
    
    private static long mdc (long a, long b) {
        while (a % b != 0) {
            long tmp = b;
            b = a % b;
            a = tmp;
        }
        return b;
    }
    
    private static long mmc (long a, long b) {
        return a / mdc (a, b) * b;
    }
    
    /** Numerador */
    long n;
    /** Denominador */
    long d;
    
    public Racional (long numerador, long denominador) {
        n = numerador;
        d = denominador;
    }
    
    public String toString() {
        return n + "/" + d;
    }
    
    public Racional adicionar (Racional a) {
        return new Racional (... complete aqui);
    }
    public Racional subtrair (Racional a) {
        return new Racional (... complete aqui);
    }
    public Racional multiplicar (Racional a) {
        return new Racional (... complete aqui);
    }
    public Racional dividir (Racional a) {
        return new Racional (... complete aqui);
    }
    
    public static void main(String[] args) {
        Racional a = new Racional (3, 4);
        Racional b = new Racional (1, 3);
        System.out.println (a.adicionar(b));
        System.out.println (a.subtrair(b));
        System.out.println (a.multiplicar(b));
        System.out.println (a.dividir(b));
    }
}

a soma ja estah feita.
as outras operacoes segue o mesmo principio.

[code]public class Main {
public static void main(String[] args) {
Racional r1 = new Racional(10, 2);
Racional r2 = new Racional(15, 6);
Racional r = r1.soma(r2);

	System.out.println(r.exibirComBarras());
	r.simplificar();
	System.out.println(r.exibirComBarras());
}

}

class Racional {
int numerador;
int denominador;

public Racional() {
	
}

public Racional(int numerador, int denominador) {
	setNumerador(numerador);
	setDenominador(denominador);
}

public int getNumerador() {
	return numerador;
}

public void setNumerador(int numerador) {
	this.numerador = numerador;
}

public int getDenominador() {
	return denominador;
}

public void setDenominador(int denominador) {
	if(denominador == 0) {
		denominador = 1;
	}
	this.denominador = denominador;
}

public String exibirComBarras() {
	return numerador + "/" + denominador;
}

public String exibirComDecimais() {
	return String.valueOf((double) numerador / denominador);
}

public void simplificar() {
	int menor = Math.min(numerador, denominador);
	boolean primosEntreSi = false;
	while(!primosEntreSi) {
		primosEntreSi = true;
		for(int i = 2; i <= menor; i++) {
			if(numerador % i == 0 && denominador % i == 0) {
				primosEntreSi = false;
				setNumerador(numerador / i);
				setDenominador(denominador / i);
				menor = Math.min(numerador, denominador);
				break;
			}
		}
	}
}

public Racional soma(Racional outroRacional) {
	int mmc = mmc(denominador, outroRacional.getDenominador());
	int numerador = ((mmc / denominador) * this.numerador) + 
		((mmc / outroRacional.getDenominador()) * outroRacional.getNumerador());
	Racional resultado = new Racional(numerador, mmc);
	
	return resultado;
}

public int mmc(int a, int b) {
	if(a % b == 0) {
		return a;
	}
	if(b % a == 0) {
		return b;
	}
	return a * b;
}

}[/code]

[quote=julianatibaes]Ola novamente, agora um nooovo probleminha
a prof quer que faca um prog que pege o numerador , denominador e faca as continhas normais.
soma multiplica subtrai… essas coisinhas
ate ai blz
so que ela quer que imprima o resultado com o /
[/quote]

O problema é que vc não entendeu o conceito de numero racional.
Um numero racional é um numero na forma n/d em que a divisão NUNCA é efetuada.
O seu codigo faz a dividisão por isso vc nunca conseguirá um toString na forma n/d.

Crie uma classe racional com as operações entre racionais e não entre numeros sem significado.
utilize as regras de multiplicação, divisão e soma que aprendeu na escola para conseguir obter um nuemro na forma n/d exemplo

2/3 + 5/4 = 24 / 34 + 53 / 43 = (24 + 53) / 4*3 = (15 + 8) / 12 = 23 / 12

class Racional {

   int numerador;
   int denominador;

   public Racional plus ( Racional other){
       /// soma 
   }

   public Racional minus( Racional other){
       /// subtrai
   }

   public Racional times( Racional other){
       /// multiplica
   }

   public Racional over( Racional other){
       /// divide
   }

   public String toString(){
     return numerador + "/" + denominador;
   }
}

Seu professor não vai aceitar isto, mas é interessante - isto implementa um algoritmo que converte um double em um número racional aproximado.

import java.math.*;
import java.util.*;

class Rational {
    private BigInteger numerator;
    private BigInteger denominator;
    public Rational (long n) {
        numerator = new BigInteger (Long.toString (n)); denominator = BigInteger.ONE;
    }
    public Rational (BigInteger n, BigInteger d) {
        numerator = n; denominator = d;
        simplify();
    }
    public Rational (Rational r) {
        numerator = r.numerator;
        denominator = r.denominator;
    }
    public Rational () {
        numerator = BigInteger.ZERO;
        denominator = BigInteger.ONE;
    }
    public String toString() { return numerator + "/" + denominator; }
    
    public static Rational add (Rational x, Rational y) {
        return new Rational (
            x.numerator.multiply (y.denominator).add(y.numerator.multiply (x.denominator)),
            x.denominator.multiply (y.denominator));
    }

    public static Rational sub (Rational x, Rational y) {
        return new Rational (
            x.numerator.multiply (y.denominator).subtract(y.numerator.multiply (x.denominator)),
            x.denominator.multiply (y.denominator));
    }

    public static Rational mul (Rational x, Rational y) {
        return new Rational (
            x.numerator.multiply (y.numerator),
            x.denominator.multiply (y.denominator));
    }
    public static Rational div (Rational x, Rational y) {
        return new Rational (
            x.numerator.multiply (y.denominator),
            x.denominator.multiply (y.numerator));
    }
    public static Rational inv (Rational x) {
        return new Rational (x.denominator, x.numerator);
    }
    private void simplify () {
        if (!numerator.equals (BigInteger.ZERO)) {
            BigInteger gcd = numerator.gcd (denominator);
            numerator = numerator.divide(gcd);
            denominator = denominator.divide(gcd);
        } else {
            denominator = BigInteger.ONE;
        }
    }
    public double doubleValue() {
        return numerator.doubleValue() / denominator.doubleValue();
    }        

}

class Rat {
    public Rational rat (double x, double tolerance) {
        long[] d = new long[21];
        int k = d.length-1;
        for (int i = 0; i < d.length; ++i) {
            d [i] = (long) x; // picking off the integer part
            if (x - d[i] < tolerance) {
                k = i;
                break;
            }
            x = 1 / (x - d[i]);
        }
        //-- Uma vez que temos os termos, devemos achar o valor correto        
        // Calculando 1/dk, somando com d[k-1], invertendo e assim por diante.
        Rational q = new Rational (d[k]);
        for (int i = k; i >= 1; --i) {
            q = Rational.inv (q); 
            q = Rational.add (q, new Rational (d[i-1])); 
        }
        return q;
    }
 
    
    public static void main(String[] args) {
        double tolerance = 1E-10;
        Rat r = new Rat();
        Rational f;
        f = r.rat (4.0 / 3.0, tolerance); // 4/3
        System.out.println (f);
        f = r.rat (11.0 / 7.0, tolerance); // 11/7
        System.out.println (f);
        f = r.rat (7.0 / 1999.0, tolerance); // 7/1999
        System.out.println (f);
        f = r.rat (0.75, tolerance); // 3/4
        System.out.println (f);
        f = r.rat (18.69, tolerance); // 1869/100
        System.out.println (f);
        f = r.rat (18.691, tolerance); // 4030356987616734543/215630891210568443
        System.out.println (f);

        //-- Note que o algoritmo pode desembestar:
        f = r.rat (2005.0/2006.0, tolerance); // 14374494523137244723793128/14381663847088933356788119
        System.out.println (f);
        
        //-- Para valores famosos...
        f = r.rat (Math.sqrt(2.0), tolerance); // 54608393/38613965
        System.out.println (f); 
        f = r.rat (Math.PI, tolerance); // 42581509225984/13554115355257
        System.out.println (f);
        f = r.rat (Math.E, tolerance); // 325368125/119696244
        System.out.println (f);
        f = r.rat (Math.log (10), tolerance); // 69333509878/30111160751
        System.out.println (f);
        f = r.rat ((Math.sqrt (5.0) + 1.0) / 2.0, tolerance); // 17711/10946
        System.out.println (f);
    }
}

Substitua o
soma = (n1d2)+ (n2d1)/(d1*d2);

por

System.out.println("Soma: " + (n1d2)+ (n2d1) + “/” + (d1*d2))

resolve?