Back to index

wims  3.65+svn20090927
NaryOperator.java
Go to the documentation of this file.
00001 /*
00002 $Id: NaryOperator.java,v 1.3 2003/02/18 11:48:47 sander Exp $
00003 */
00004 
00005 
00006 /*
00007 Copyright (C) 2001-2002 Mainline Project (I3S - ESSI - CNRS -UNSA)
00008 
00009 This library is free software; you can redistribute it and/or
00010 modify it under the terms of the GNU Lesser General Public
00011 License as published by the Free Software Foundation; either
00012 version 2.1 of the License, or (at your option) any later version.
00013 
00014 This library is distributed in the hope that it will be useful,
00015 but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public
00020 License along with this library; if not, write to the Free Software
00021 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 
00023 For further information on the GNU Lesser General Public License,
00024 see: http://www.gnu.org/copyleft/lesser.html
00025 For further information on this library, contact: mainline@essi.fr
00026 */
00027 
00028 
00029 package fr.ove.openmath.jome.model;
00030 
00031 import java.util.*;
00032 import fr.ove.openmath.jome.model.*;
00033 import fr.ove.openmath.jome.model.events.*;
00034 import fr.ove.openmath.jome.model.evaluation.*;
00035 
00041 public class NaryOperator extends Operator {
00049     public FormulaTreeStructure insert(FormulaTreeStructure current) {
00050         VariableOrNumber template;
00051         // On cherche la position d'insertion de notre opérateur
00052         current = findLocation(current);
00053 
00054         if (current.getAsOperatorPriority() == getAsOperandPriority()) {
00055             // On a déjà tapé dans la formule un opérateur de ce genre, on va donc seulement insérer
00056             // un template.
00057             template = new VariableOrNumber();
00058             current.addChild(template);
00059             
00060             // On retourne la reférence de notre dernier point d'insertion.
00061             return template;
00062         }
00063         else { 
00064             // On est dans le cas où on commence à saisir un tel opérateur.
00065             
00066             // On ajoute l'opérateur comme fils à l'opérateur courant
00067             current.addChild(this);
00068             
00069             // On teste s'il on est dans le cas où l'on a déjà tapé qque chose dans
00070             // la formule. Si non, current est forcément de type Formula, par conséquent
00071             // on est dans le cas particulier où cela doit produire [?]*[?] puisque
00072             // normalement on ne devrait, dans ce cas là, pas pouvoir taper de "*"
00073             if ((current.getFather() == null) && (current.getNbChildren() == 1)) {
00074                 template = new VariableOrNumber();
00075                 addChild(template); // On ajoute le premier template.
00076             }
00077             else {
00078                 FormulaTreeStructure fts = (FormulaTreeStructure) current.getChild(getRank() - 1);
00079                 // à cause des priorités sur les opérateurs, on ajoute comme fils l'opérateur
00080                 // dont le rang est juste inférieur à notre "*"
00081                 addChild(fts);
00082                 
00083                 // on enlève l'opérateur qu'on a fait "descendre", de la liste
00084                 // de son précédent père (son grand père maintenant)
00085                 current.removeChild(fts);
00086             }
00087             
00088             // On ajoute un template à la multiplication
00089             template = new VariableOrNumber();
00090             addChild(template);
00091             
00092             // On retourne la reférence de notre dernier point d'insertion.
00093             return template;
00094         }
00095     }
00096     
00100     public String createLinear(String linear) {
00101         FormulaTreeStructure child;
00102         
00103         for (int i = 0; i < getNbChildren(); i++) {
00104             child = (FormulaTreeStructure) getChild(i);
00105             if (i == 0)
00106                 linear = child.createLinear(linear);
00107             else {
00108                 linear += getTheOperator();
00109                 linear = child.createLinear(linear);
00110             }
00111         }
00112         return linear;
00113     }
00114     
00118     public String evaluate() {
00119         Vector evaluations = new Vector();
00120         
00121         // On commence par évaluer tous les fils de l'instance
00122         for (Enumeration e = getChildren().elements(); e.hasMoreElements(); )
00123             evaluations.addElement(((FormulaTreeStructure) e.nextElement()).evaluate());
00124     
00125         int nbEvaluations = evaluations.size();
00126         String anEvaluation, currEvaluation;
00127         // Maintenant, on parcourre toutes les évaluations calculées et on essaye de leur appliquer
00128         // l'opérateur courant
00129         for (int i = 1; i < nbEvaluations; i++) {
00130             currEvaluation = (String) evaluations.elementAt(i);
00131             
00132             for (int j = 0; j < i; j++) {
00133                 anEvaluation = (String) evaluations.elementAt(j);
00134                 
00135                 if (Evaluator.type(currEvaluation) == Evaluator.type(anEvaluation)) {
00136                     evaluations.insertElementAt(Evaluator.evaluate(anEvaluation, currEvaluation, getTheOperator()), j);
00137                     evaluations.removeElement(anEvaluation);
00138                     evaluations.removeElement(currEvaluation);
00139                     i--;
00140                     nbEvaluations--;
00141                     break;
00142                 }
00143             }
00144         }
00145         
00146         // On a appliqué l'opérateur courant, on retourne maintenant le résultat, en prenant soin
00147         // d'intercaler des opérateur entre les évaluations si nécessaire
00148         String result = (String) evaluations.firstElement();
00149         for (int i = 1; i < nbEvaluations; i++)
00150             result += getTheOperator() + (String) evaluations.elementAt(i);
00151 
00152         return result;
00153     }
00154 }
00155