PageRenderTime 89ms CodeModel.GetById 48ms app.highlight 36ms RepoModel.GetById 1ms app.codeStats 0ms

/Simplex/src/mx/uacam/fdi/io/simplex/resolvedor/mate/Ecuacion.java

http://mtdsimplex.googlecode.com/
Java | 231 lines | 144 code | 24 blank | 63 comment | 43 complexity | 0376eb5f520df359ef56415c24044660 MD5 | raw file
  1/*
  2 * @(#)Ecuacion.java 1.7.1 10/10/09
  3 * @charset "utf-8";
  4 * Copyright (c) pendiente.
  5 */
  6package mx.uacam.fdi.io.simplex.resolvedor.mate;
  7
  8import java.io.Serializable;
  9import java.util.ArrayList;
 10import java.util.List;
 11import java.util.regex.Matcher;
 12import java.util.regex.Pattern;
 13
 14/**
 15 *
 16 * Esta clase es la que realiza las operaciones y devuelve los resultados para
 17 * que sean graficados.
 18 *
 19 * @author Neo Cs || [El ??gel Blanco]
 20 * @version 1.7.1, 10/10/09
 21 */
 22public class Ecuacion implements Serializable{
 23    
 24    private static final long serialVersionUID = 5601572475251277384L;
 25    private OperadorRelacional tipoIgualdad;
 26    private List<Monomio> monomios;
 27    private Monomio monomioResultado;
 28    private int resultado;
 29
 30    /**
 31     * 
 32     * @param unaEcuacion 
 33     */
 34    public Ecuacion(String unaEcuacion) {
 35        unaEcuacion = unaEcuacion.trim();
 36        unaEcuacion = unaEcuacion.toLowerCase();
 37
 38        String[] cadenaNueva = unaEcuacion.split("<=");
 39        if (cadenaNueva.length == 2) {
 40            tipoIgualdad = OperadorRelacional.MENOR_IGUAL_QUE;
 41        } else if ((cadenaNueva = unaEcuacion.split(">=")).length == 2) {
 42            tipoIgualdad = OperadorRelacional.MAYOR_IGUAL_QUE;
 43        } else if ((cadenaNueva = unaEcuacion.split("=")).length == 2) {
 44            tipoIgualdad = OperadorRelacional.IGUAL;
 45        } else if ((cadenaNueva = unaEcuacion.split(">")).length == 2) {
 46            tipoIgualdad = OperadorRelacional.MAYOR_QUE;
 47        } else if ((cadenaNueva = unaEcuacion.split("<")).length == 2) {
 48            tipoIgualdad = OperadorRelacional.MENOR_QUE;
 49        } else {
 50            throw new IllegalArgumentException("Ecuaci??n no valida: " + unaEcuacion);
 51        }
 52
 53        String regexMonomio = "([-\\+]*\\d*[a-y]\\d+)";
 54        Pattern p = Pattern.compile(regexMonomio);
 55        Matcher m = p.matcher(unaEcuacion);
 56
 57        List<Monomio> monomios = new ArrayList<Monomio>();
 58        while (m.find()) {
 59            String group = m.group();            
 60            monomios.add(new Monomio(group));
 61        }
 62
 63        this.monomios = monomios;
 64
 65        if (cadenaNueva[1].length() > cadenaNueva[0].length()) {
 66            try {                
 67                resultado = Integer.parseInt(cadenaNueva[0]);
 68            } catch (NumberFormatException ex) {                
 69                monomioResultado = new Monomio(cadenaNueva[0]);
 70            }            
 71        } else {
 72            try {                
 73                resultado = Integer.parseInt(cadenaNueva[1]);
 74            } catch (NumberFormatException ex) {                
 75                monomioResultado = new Monomio(cadenaNueva[1]);
 76            }
 77        }
 78    }
 79
 80    /**
 81     *
 82     * @param monomios
 83     * @param tipoIgualdad
 84     * @param resultado
 85     */
 86    public Ecuacion(Monomio[] monomios, OperadorRelacional tipoIgualdad, int resultado) {
 87        setMonomios(monomios);
 88        setResultado(resultado);
 89        setTipoIgualdad(tipoIgualdad);
 90    }
 91
 92    /**
 93     *
 94     * @param monomios
 95     * @param tipoIgualdad
 96     * @param monomioResultado
 97     */
 98    public Ecuacion(Monomio[] monomios, OperadorRelacional tipoIgualdad, Monomio monomioResultado) {
 99        setMonomioResultado(monomioResultado);
100        setMonomios(monomios);
101        setTipoIgualdad(tipoIgualdad);
102    }
103
104    /**
105     * @return the tipoIgualdad
106     */
107    public OperadorRelacional getTipoIgualdad() {
108        return tipoIgualdad;
109    }
110
111    /**
112     * @param tipoIgualdad the tipoIgualdad to set
113     */
114    public void setTipoIgualdad(OperadorRelacional tipoIgualdad) {
115        switch (tipoIgualdad) {
116            case IGUAL:
117            case MAYOR_QUE:
118            case MENOR_QUE:
119            case MAYOR_IGUAL_QUE:
120            case MENOR_IGUAL_QUE:
121                this.tipoIgualdad = tipoIgualdad;
122                break;
123            default:
124                throw new IllegalArgumentException("Error tipo desigualdad o igualdad invalida");
125        }
126    }
127
128    /**
129     * @return the monomios
130     */
131    public Monomio[] getMonomios() {
132        return monomios.toArray(new Monomio[0]);
133    }
134
135    /**
136     * @param monomios the monomios to set
137     */
138    public void setMonomios(Monomio[] monomios) {
139        this.monomios = new ArrayList<Monomio>();
140        if (monomios != null) {
141            for (Monomio i : monomios) {
142                addMonomio(i);
143            }
144        }
145    }
146
147    /**
148     * @return the resultado
149     */
150    public int getResultado() {
151        return resultado;
152    }
153
154    /**
155     * @param resultado the resultado to set
156     */
157    public void setResultado(int resultado) {
158        this.resultado = resultado;
159    }
160
161    /**
162     * A??ade un <tt>Monomio</tt> al objeto <tt>Ecuacion</tt>
163     * 
164     * @param monomio {@code Monomio}
165     */
166    public void addMonomio(Monomio monomio) {
167        monomios.add(monomio);
168    }
169
170    /**
171     *
172     * @param index
173     * @return the Monomio
174     */
175    public Monomio getMonomio(int index) {
176        return monomios.get(index);
177    }
178
179    /**
180     * @return the monomioResultado
181     */
182    public Monomio getMonomioResultado() {
183        return monomioResultado;
184    }
185
186    /**
187     * @param monomioResultado the monomioResultado to set
188     */
189    public void setMonomioResultado(Monomio monomioResultado) {
190        this.monomioResultado = monomioResultado;
191    }
192
193    @Override
194    public boolean equals(Object obj) {
195        if (obj == null) {
196            return false;
197        }
198        if (getClass() != obj.getClass()) {
199            return false;
200        }
201        final Ecuacion other = (Ecuacion) obj;
202        if (this.tipoIgualdad != other.tipoIgualdad) {
203            return false;
204        }
205        if (this.monomios != other.monomios && (this.monomios == null || !this.monomios.equals(other.monomios))) {
206            return false;
207        }
208        if (this.monomioResultado != other.monomioResultado && (this.monomioResultado == null || !this.monomioResultado.equals(other.monomioResultado))) {
209            return false;
210        }
211        if (this.resultado != other.resultado) {
212            return false;
213        }
214        return true;
215    }
216
217    @Override
218    public int hashCode() {
219        int hash = 3;
220        hash = 67 * hash + (this.tipoIgualdad != null ? this.tipoIgualdad.hashCode() : 0);
221        hash = 67 * hash + (this.monomios != null ? this.monomios.hashCode() : 0);
222        hash = 67 * hash + (this.monomioResultado != null ? this.monomioResultado.hashCode() : 0);
223        hash = 67 * hash + this.resultado;
224        return hash;
225    }
226
227    @Override
228    public String toString() {
229        return "Ecuacion{ monomios=" + monomios + ", tipoIgualdad=" + tipoIgualdad + ", monomioResultado=" + monomioResultado + ", resultado=" + resultado + '}';
230    }
231}