Back to index

wims  3.65+svn20090927
Substraction.java
Go to the documentation of this file.
00001 /*
00002 $Id: Substraction.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.evaluation.*;
00034 
00046 public class Substraction extends BinaryOperator {
00054     public FormulaTreeStructure insert(FormulaTreeStructure current) {
00055         // On cherche la position d'insertion de notre "-"
00056         current = findLocation(current);
00057         int currentAsOperandPriority = current.getAsOperandPriority();
00058         int currentAsOperatorPriority = current.getAsOperatorPriority();
00059         
00060         if (currentAsOperatorPriority == getAsOperandPriority()) {
00061             // On a déjà tapé dans la formule un "-", on va donc insérer un nouveau
00062             // "-" dans le précédent ==> cas particuliers.
00063             if ((currentAsOperandPriority == resourcesManager.getAsOperandPriority("unaryPlusPriorities")) || 
00064                 (currentAsOperandPriority == resourcesManager.getAsOperandPriority("unaryMinusPriorities"))) {
00065                 // Si on est en précense de ce cas là, la position d'insertion est
00066                 // sur un op. unaire ("+"  ou "-"). Il faut récupérer le père de l'op.
00067                 // en question, i.e. une instance d'Addition que l'on a inséré auparavant
00068                 // dansla FST.
00069                 FormulaTreeStructure father = (FormulaTreeStructure) current.getFather();
00070                 
00071                 // Si notre position d'insertion est un "+" unaire, alors on va l'éliminer
00072                 // pour ne garder que son opérande. Ainsi, au lieu d'avoir +a-b, on aura a-b.
00073                 if (currentAsOperandPriority == resourcesManager.getAsOperandPriority("unaryPlusPriorities")) {
00074                     FormulaTreeStructure operand = (FormulaTreeStructure) current.getChild(0);
00075                     int rank = current.getRank();
00076                     
00077                     father.addChild(operand, rank);
00078                     father.removeChild(current);
00079                 }
00080                 
00081                 // On ajoute notre op. "-".
00082                 // (Rappel : "-" unaire à cause de la def. de la soustraction)
00083                 father = (new UnaryMinus()).insert(father);
00084                 
00085                 // On retourne la reférence de notre dernier point d'insertion.
00086                 return father;
00087             }
00088             
00089             // Là, on est dans le cas où l'on a tapé une série de "+" ou de "-", et donc
00090             // la position d'insertion est une instance d'Addition que l'on a inséré 
00091             // auparavant dans la FST. (tjrs le même rappel quand aux defs.)
00092             current = (new UnaryMinus()).insert(current);
00093             
00094             // On retourne la reférence de notre dernier point d'insertion.
00095             return current;
00096         }
00097         else { // Première entrée d'une soustraction (et même, aucune addition n'a été
00098                // saisie auparavant)
00099                
00100             // On ajoute une instance d'Addition comme fils à l'opérateur courant
00101             FormulaTreeStructure addition = new Addition();
00102             current.addChild(addition);
00103             
00104             if (current.getNbChildren() > 1) {
00105                 // Il faut que l'on fasse la distinction entre le fait de vouloir saisir une soustraction
00106                 // ou un moins unaire.
00107                 // Donc on vient d'ajouter une instance d'addition à current.
00108                 // Si on est là, 2 solutions, le fils de current qui a pour rank, le rank de 
00109                 // l'instance d'addition -1 :
00110                 //      * est un template ==> on saisi un moins unaire
00111                 //      * n'est pas un template ==> on saisi une soustraction
00112                 FormulaTreeStructure fts = (FormulaTreeStructure) current.getChild(addition.getRank() - 1);
00113                 
00114                 // Quelque soit le cas, on enlève fts de current.
00115                 // Dans le cas du moins unaire, (fts est un template) un template sera rajouté avec
00116                 // l'insertion du UnaryMinus
00117                 // Dans le cas de la soustraction, fts sera ajouté à l'instance d'addition
00118                 current.removeChild(fts);
00119                 
00120                 if (!((fts.getAsOperatorPriority() == resourcesManager.getAsOperatorPriority("constantPriorities")) &&
00121                     fts.isTemplate())) {
00122                     // Donc, c'est une soustraction, fts est l'élement à qui on va soustraire qque chose.
00123                     // On l'ajoute donc comme fils (en fait ce sera la premier) à l'instance d'addition.
00124                     addition.addChild(fts);
00125                 }
00126                 
00127                 // Par définition de la soustraction, on ajoute un opérateur "-"
00128                 // unaire comme fils à l'instance d'Addition.
00129                 addition = (new UnaryMinus()).insert(addition);
00130                 
00131                 // On retourne la référence de notre dernier point d'insertion
00132                 return addition;
00133             }
00134             else { // on est dans le cas du moins unaire
00135                 // On ajoute un opérateur "-" unaire comme fils à l'instance d'Addition.
00136                 addition = (new UnaryMinus()).insert(addition);
00137                 
00138                 // On retourne la reférence de notre dernier point d'insertion.
00139                 return addition;
00140             }
00141         }
00142     }
00143 }