aqui ire poniendo todos los codigos que haga en java por si a alguien le interesa. Puede que algunos sean muy tontos pero tambien puede que a alguien le sirva

-ecu2ºGrado
-mcd(maximo comun divisor)
-mcm(minimo comun multiplo)

Ecuacion de 2ºgrado del tipo ax^2+bx+c
Deben estar los 3 parametros y ser diferentes a 0 los 3. Debería poderse hacer si c=0 y demas, pero no tengo ganas por ahora, ya lo hare!

[syntax="java"]public static String ecu2Grado(Double a, Double b, Double c) {
Double resultado1 = 0.0;
Double resultado2 = 0.0;
//Controlamos los datos que nos pasan, si son menores que 0 lanzamos el error
if( a = 0 || b = 0.0 || c = 0.0){
throw new IllegalArgumentException("Te he dicho que no introduzcas 0, ahora no arrancará mas tu pc!!");
}

//realizamos las operaciones de la ecu de 2º grado

resultado1 = (-b + (Math.sqrt(b * b - 4 * a * c)) / 2 * a);
resultado2 = (-b - (Math.sqrt(b * b - 4 * a * c)) / 2 * a);

//mostramos el resultado como una string

return "El 1º resultado es: " + resultado1 + " ,El 2º resultado es: "+ resultado2;
}
[/syntax]

[syntax="java"]
//mcd por el metodo de euclides

public static Integer mcd(Integer a, Integer b) {
for (; a != b;) {
if (a < b) {
b = b - a;
} else {
a = a - b;
}
}
return a;
}[/syntax]

[syntax="java"]
//mcm por laa propiedad entre el mcd y el mcm
public static Integer mcm(Integer a, Integer b) {
return a * b / mcd(a, b);
}[/syntax]
En 1º en 2º o en 3º BETICO hasta que muera
Vas mejorando pero para estos ejemplos no deberias usar objetos, sino valores primitivos. Critica constructiva.
adwind escribió:Vas mejorando pero para estos ejemplos no deberias usar objetos, sino valores primitivos. Critica constructiva.
No es personal adwind aun que paresca... xD No existen las criticas contructivas, te referiras a critica objetiva !
Lindos source se aprecia el esfuerzo y alguna vez pueden servir Gracias @davidad
1337 & culture!
tengo muchisimos mas!! pero doc me dijo que me esperase a que arreglase el problema de foro.... ¬¬
adwin no me molesta!! pero me OBLIGAN! a usar los tipo objecto porque dice que tienen metodos que nos ayudaran! vaaa me he acostumbrado asi que no me molesta usarlo xDD

gracias a los 2 !! sois los que siempre aportais cosas de java!!
En 1º en 2º o en 3º BETICO hasta que muera
davidad escribió:tengo muchisimos mas!! pero doc me dijo que me esperase a que arreglase el problema de foro.... ¬¬
adwin no me molesta!! pero me OBLIGAN! a usar los tipo objecto porque dice que tienen metodos que nos ayudaran! vaaa me he acostumbrado asi que no me molesta usarlo xDD

gracias a los 2 !! sois los que siempre aportais cosas de java!!
Realmente yo no aporto mucho apenas me estoy introduciendo con java poco a poco, los creditos son de @adwind el si se saca buenas cartas de la manga!
1337 & culture!
Aqui teneis un tipo entero, bueno el mejor tipo que he hecho por ahora. Es el tipo polinomio.
Un poco mas abajo teneis lo que nos dan en clase y a partir de ello debemos sacar todo esto.
lo subo porque esta todo perfecto, incluso le añadi algunas funciones extras como simplificar el polinomio y mas y podria ser un bonito codigo para una buena calculadora, tambien tengo el tipo racional(fracciones) por si a algien le interesa
Darle un vistazo primero al pdf para ver que me piden y luego al code si quereis.

Con respecto al code espero mejoras pues alguna funciones pienso que son una chapuza tela de buena



[Enlace externo eliminado para invitados]


Aqui la interfaz(no es muy grande)
[syntax="java"]
import fp.utilidades.Copiable;



public interface Polinomio extends Copiable<Polinomio> {


public void setCoeficientes(Integer coef1);

// El elemento i-ésimo se corresponderá con el coeficiente de grado i del polinomio
public Integer getGrado(); // Grado, de tipo Integer, derivada // Se corresponde con el exponente del término de mayor grado


// Consultar o modificar el coeficiente de un grado determinado
public Integer getCoeficiente(Integer grado1);

// public List<Integer> getCoeficiente();
public void setCoeficiente(Integer coef1,Integer grado1);
// Añadir un nuevo coeficiente (el grado del polinomio aumentará en uno)
public void agregaCoeficiente(Integer coef1);
// Sumar una cantidad dada al coeficiente de un determinado grado
public void sumarCoeficiente(Integer coef1, Integer grado1);
// Multiplicar todos los coeficientes por una cantidad dada
public void multiplicarCoeficiente(Integer numMultiplicador1);
// divide todos los coef por un numero
public void dividirCoeficiente(Integer numDivisior1);
// Realizar la suma con otro polinomio
public void sumaPolinomio(Polinomio pol1);
// Realizar la resta con otro polinomio
public void restaPolinomio(Polinomio pol1);
// Realizar la derivada
public void derivar();
// Calcular el valor del polinomio para un valor real de la variable x
public Integer resolverX(Integer valorX);
// Multiplicar polinomio por un monomio
public void multiplicarMonomio(Polinomio pol1);
// Simplifica todos los coef del polinomio
public void simplificar();
}
[/syntax]
Aqui la Clase...(es bastante larga...)


[syntax="java"]
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

import fp.utilidades.Enteros;

public class PolinomioImpl implements Polinomio {

private List<Integer> ltCoef = new LinkedList<Integer>();

// Representación como cadena:
// Ejemplo: -3X^5+1X^4-5X^3-3X^1 (se omiten los términos con coeficientes 0)
// Dos polinomios serán iguales si tienen el mismo grado y si los
// coeficientes de ambos polinomios coinciden para cada grado

public PolinomioImpl() {
ltCoef.add(0);
}

// Constructor a partir de un array de enteros. Creará un polinomio cuyos
// coeficientes se corresponderán con los valores contenidos en el array.
public PolinomioImpl(Integer[] arrayInt) {
List<Integer> ltCof = Arrays.asList(arrayInt);
ltCoef = ltCof;

}

public PolinomioImpl(List<Integer> lista) {
for (Integer e : lista) {
if (e.equals(null)) {
throw new GradoNoValidoExcepcion("Atencion, un dato es null");
}
}
ltCoef = lista;
}

// Busca el primer no 0 dentro del polonomio, el 1º numero de coef distinto
// a 0
private Integer buscaNoCero(Polinomio pol1) {
Integer pos = 0;
for (int i = 0; i < pol1.getGrado(); i++) {
if (!pol1.getCoeficiente(i).equals(0)) {
pos = i;
}
}
return pos;
}

private void eliminarCerosIzquierda() {

for (Integer i = getGrado(); i >= 1; i--) {

if (getCoeficiente(i - 1).equals(0)) {
ltCoef.remove(i - 1);
} else {
break;
}

}
}

public void simplificar() {
// Ese agrega es para poder hacer lo que esta dentro del for sin problemas de un IndexOutOfBoundsException.
if (ltCoef.size() <= 1) {
agregaCoeficiente(0);
agregaCoeficiente(0);
}
Integer mcd1 = Enteros.mcd(getCoeficiente(0), getCoeficiente(1));
Integer mcd2 = 0;
for (int i = 1; i < ltCoef.size(); i++) {

mcd2 = Enteros.mcd(getCoeficiente(i), mcd1);

}

dividirCoeficiente(mcd2);
}

public void setCoeficientes(Integer coef1) {
if (coef1.equals(null)) {
throw new GradoNoValidoExcepcion("Error en el coeficiente");
}
ltCoef.add(coef1);
}

public Integer getGrado() {
return ltCoef.size();
}

// Agregar el coeficiente de un grado determinado
public void agegaCoeficientes(Integer coef1, Integer grado1) {
if (coef1.equals(null)) {
throw new GradoNoValidoExcepcion("Error en el coeficiente");
}

if (grado1 < 0 || grado1.compareTo(getGrado()) > 0) {
throw new GradoNoValidoExcepcion("Error en el grado");
}

ltCoef.set(grado1, coef1);
// formaCanonica();
}

// Consultar el coeficiente de un grado determinado
public Integer getCoeficiente(Integer grado) {
if (grado < 0 || grado.compareTo(getGrado()) > 0) {
throw new GradoNoValidoExcepcion(
"El grado no puede ser el introducido");
}
return ltCoef.get(grado);
}

// modificar el coeficiente de un grado determinado
public void setCoeficiente(Integer coef1, Integer grado1) {
if (grado1 < 0 || grado1.compareTo(getGrado()) > 0) {
throw new GradoNoValidoExcepcion("Error");
}
ltCoef.set(grado1, coef1);
// formaCanonica();
}

// Añadir un nuevo coeficiente (el grado del polinomio aumentará en uno)
public void agregaCoeficiente(Integer coef1) {
if (coef1.equals(null)) {
throw new GradoNoValidoExcepcion("Error en el coeficiente");
}
ltCoef.add(coef1);
}

// Sumar una cantidad dada al coeficiente de un determinado grado
public void sumarCoeficiente(Integer coef1, Integer grado1) {
if (coef1.equals(null)) {
throw new GradoNoValidoExcepcion("Error en el coeficiente");
}
if (grado1 < 0 || grado1.compareTo(getGrado()) > 0) {
throw new GradoNoValidoExcepcion("Error");
}
ltCoef.set(grado1, getCoeficiente(grado1) + coef1);
}

// Realizar la suma con otro polinomio
public void sumaPolinomio(Polinomio pol1) {
Integer maximo = Math.max(getGrado(), pol1.getGrado());
for (int i = getGrado(); i < pol1.getGrado(); i++) {
agregaCoeficiente(0);
}

for (int i = 0; i < maximo; i++) {
ltCoef.set(i, getCoeficiente(i) + pol1.getCoeficiente(i));

}
}

public void restaPolinomio(Polinomio pol1) {
Integer maximo = Math.max(getGrado(), pol1.getGrado());
for (int i = getGrado(); i < pol1.getGrado(); i++) {
agregaCoeficiente(0);
}

for (int i = 0; i < maximo; i++) {
ltCoef.set(i, getCoeficiente(i) - pol1.getCoeficiente(i));

}
}

// Multiplicar todos los coeficientes por una cantidad dada
public void multiplicarCoeficiente(Integer numMultiplicador1) {
if (numMultiplicador1.equals(null)) {
throw new GradoNoValidoExcepcion("Error en el coeficiente");
}
for (int i = 0; i < ltCoef.size(); i++) {
ltCoef.set(i, getCoeficiente(i) * numMultiplicador1);
}
}

// Multiplica un polinomio por un monomio
public void multiplicarMonomio(Polinomio pol1) {
// CHAPUZA??
List<Integer> ltInt = new LinkedList<Integer>();
Integer pos = buscaNoCero(pol1);

Integer gradoMaximo = getGrado() + pol1.getGrado();

for (int i = 0; i < gradoMaximo; i++) {
ltInt.add(0);
}

for (int i = 0; i < getGrado(); i++) {
ltInt.set(i + pos, getCoeficiente(i) * pol1.getCoeficiente(pos));
}
ltCoef.clear();
ltCoef = ltInt;
eliminarCerosIzquierda();
}

// Divide un polinomio por un numero
public void dividirCoeficiente(Integer numDivisior1) {
for (int i = 0; i < ltCoef.size(); i++) {
ltCoef.set(i, getCoeficiente(i) / numDivisior1);
}
}

// Realizar la derivada
public void derivar() {
// creo que es una chapuza pero no se como mejorarlo
Integer res = 0;
for (int e = 0; e < getGrado(); e++) {

ltCoef.set(e, getCoeficiente(e) * (e));
}

for (int e = 0; e < getGrado() - 1; e++) {

res = getCoeficiente(e + 1);
setCoeficiente(res, e);
}
ltCoef.remove(getGrado() - 1);
}

// Calcular el valor del polinomio para un valor real de la variable x
public Integer resolverX(Integer valorX) {
Integer resultado = 0;
for (int e = ltCoef.size() - 1; e >= 0; e--) {

resultado = (int) (getCoeficiente(e) * Math.pow(valorX, e))
+ resultado;
}
return resultado;
}

public String toString() {
String sig = "";
String resultado = "";
if (getCoeficiente(0).equals(0)) {

} else {
if (getCoeficiente(0) > 0) {
sig = "+";
}
resultado = sig + getCoeficiente(0);
}
String signo = "";

for (int e = 1; e < getGrado(); e++) {
Integer op = getCoeficiente(e);
if (op > 0) {
signo = "+";
} else {
// LOS MUERTOS DE ESTE PASO, ME HA COSTADO DIAS VERLO.....
// Mi problema que al asignar signo = "+", cuando el numero
// era negativo se ponia +-5x^2 (Ejemplo)
// y era porque yo evaluava si el coeficiente era mayor que 0,
// entonces ponia el signo mas, pero si era menor no hacia nada
// y claro la variable
// signo tenia el valor "+" de antes y me salia ese fallo....
signo = "";
}
if (op.equals(0)) {
} else {
resultado = signo + op + "x^" + e + resultado;
}
}

// Por si quereis lo de antes con un for extendido

// Integer i = 0;
// for (Integer coef : ltCoef) {
// if (coef > 0) {
// signo = "+";
// }else{
// signo = "";
//
// if (coef.equals(0)) {
// } else {
//
// resultado = signo + coef + "x^" + i + resultado;
//
// }
// i++;
// }

return resultado;
}

public int hashCode() {
return ltCoef.hashCode();
}

public boolean equals(Object o) {
boolean resultado = false;
if (o instanceof Polinomio) {
Polinomio pol = (Polinomio) o;
resultado = pol.getGrado().equals(getGrado()) ;
}
return resultado;
}

public Polinomio clone(){
Polinomio pol1 = null;
try{
pol1=(Polinomio) super.clone();
}catch
(CloneNotSupportedException exr){
;
}

return pol1;
}
}
[/syntax]

Aqui la excepcion personalizada
[syntax="java"]
public class GradoNoValidoExcepcion extends RuntimeException {

private static final long serialVersionUID = 1L;

public GradoNoValidoExcepcion() {
super();
}

public GradoNoValidoExcepcion(String arg) {
super(arg);
}
}
[/syntax]
Como veran es muy facil hacer excepciones en java
En 1º en 2º o en 3º BETICO hasta que muera
Responder

Volver a “Fuentes”