Beispiel #1
0
        /// <summary>
        /// Appends new symbol to this object
        /// </summary>
        /// <param name="symbol">the symbol to append</param>
        public void Append(MathSymbol symbol)
        {
            MathSymbol s = Next;

            if (s != null)
            {
                s.Insert(symbol);
                return;
            }
            parent.InsertObject(symbol);
        }
Beispiel #2
0
        /// <summary>
        /// Creates Element from symbol
        /// </summary>
        /// <param name="symbol">The symbol</param>
        /// <param name="document">The doucument</param>
        /// <param name="creator">Creator</param>
        /// <returns>The element</returns>
        public static XElement CreateElement(MathSymbol symbol,
                                             IXmlSymbolCreator creator)
        {
            XElement e = creator.CreateElement(symbol);

            for (int i = 0; i < symbol.Count; i++)
            {
                XElement el = MathFormula.CreateElement(symbol[i], creator);
                e.Add(el);
            }
            return(e);
        }
Beispiel #3
0
 /// <summary>
 /// Appends the symbol to formula
 /// </summary>
 /// <param name="formula">Formula the formula to append</param>
 /// <returns>Next inserted object</returns>
 public MathFormula Append(MathFormula formula)
 {
     try
     {
         MathSymbol symbol = (MathSymbol)Clone();
         symbol.SetToFormula(formula);
         formula.Add(symbol);
         symbol.parent = formula;
     }
     finally
     {
     }
     return(formula);
 }
Beispiel #4
0
 /// <summary>
 /// Wraps this symbol by brackets
 /// </summary>
 /// <returns>Next symbol</returns>
 public MathSymbol Wrap(string prohibited)
 {
     sym = Next;
     if (ShouldWrapped)
     {
         Insert(Bra);
         Append(Ket);
     }
     if (HasChildren)
     {
         for (int i = 0; i < Count; i++)
         {
             this[i].Wrap(prohibited);
         }
     }
     return(sym);
 }
Beispiel #5
0
 /// <summary>
 /// Checks whether children contains the symbol
 /// </summary>
 /// <param name="s">the symbol</param>
 /// <returns>the result of checking</returns>
 public bool Contains(MathSymbol s)
 {
     if (s == this)
     {
         return(true);
     }
     if (HasChildren)
     {
         for (int i = 0; i < Count; i++)
         {
             if (this[i].Contains(s))
             {
                 return(true);
             }
         }
     }
     return(false);
 }
Beispiel #6
0
        /// <summary>
        /// Craeates symbol from Xml element
        /// </summary>
        /// <param name="e">The element</param>
        /// <param name="creator">The creator</param>
        /// <returns>The symbol</returns>
        public static MathSymbol CreateSymbol(XElement e, IXmlSymbolCreator creator)
        {
            MathSymbol             s    = creator.CreateSymbol(e);
            IEnumerable <XElement> l    = e.GetElementsByTagName("F");
            List <MathFormula>     list = new List <MathFormula>();

            foreach (XElement el in l)
            {
                if (el.Parent != e)
                {
                    continue;
                }
                MathFormula f = MathFormula.CreateFormula(el, creator);
                list.Add(f);
            }
            s.Children = list;
            return(s);
        }
Beispiel #7
0
 /// <summary>
 /// Inserts symbol
 /// </summary>
 /// <param name="formula">The formula to insert</param>
 /// <param name="previosSymbol">The previos symbol</param>
 /// <returns>Inserted object</returns>
 public object InsertBefore(MathFormula formula, MathSymbol previosSymbol)
 {
     try
     {
         MathSymbol symbol = (MathSymbol)Clone();
         symbol.SetToFormula(formula);
         int n = formula.IndexOf(previosSymbol);
         formula.Insert(n, symbol);
         symbol.parent = formula;
         if (symbol is BracketsSymbol)
         {
             return(symbol[0]);
         }
         return(symbol.NextObject);
     }
     finally
     {
     }
 }
Beispiel #8
0
 private static void getOperationIndexes(MathFormula formula, List <int> list)
 {
     for (int i = 0; i < formula.Count; i++)
     {
         MathSymbol s = formula[i];
         for (int j = 0; j < s.Count; j++)
         {
             getOperationIndexes(s[j], list);
         }
         if (!(s is SeriesSymbol))
         {
             continue;
         }
         SeriesSymbol ss  = s as SeriesSymbol;
         int          ind = ss.index;
         if (!list.Contains(ind))
         {
             list.Add(ind);
         }
     }
 }
Beispiel #9
0
 /// <summary>
 /// Makes copy of the symbol
 /// </summary>
 /// <returns>the copy</returns>
 public MathSymbol Copy()
 {
     try
     {
         sym = Clone() as MathSymbol;
         if (children != null)
         {
             sym.children = new List <MathFormula>();
             for (int i = 0; i < Count; i++)
             {
                 if (this[i] != null)
                 {
                     sym.children.Add(this[i].Copy());
                 }
             }
         }
         sym.doubleValue = doubleValue;
         return(sym);
     }
     finally
     {
     }
 }
Beispiel #10
0
 /// <summary>
 /// Sets operations to formula
 /// </summary>
 /// <param name="formula">The formula</param>
 /// <param name="table">Table of operations</param>
 public static void SetOperations(MathFormula formula, Dictionary <int, IOperationAcceptor> table)
 {
     for (int i = 0; i < formula.Count; i++)
     {
         MathSymbol s = formula[i];
         for (int j = 0; j < s.Count; j++)
         {
             SetOperations(s[j], table);
         }
         if (!(s is SeriesSymbol))
         {
             continue;
         }
         SeriesSymbol ss  = s as SeriesSymbol;
         int          ind = ss.index;
         ss.acceptor = null;
         if (!table.ContainsKey(ind))
         {
             throw new Exception("Operation with index " + ind + " does not exist");
         }
         IOperationAcceptor acc = table[ind];
         ss.acceptor = acc;
     }
 }
Beispiel #11
0
 /// <summary>
 /// Resets auxiliary variables
 /// </summary>
 public void Zero()
 {
     sym  = null;
     sym1 = null;
 }
Beispiel #12
0
 /// <summary>
 /// Insetrs symbol before this symbol
 /// </summary>
 /// <param name="symbol">The symbol</param>
 /// <param name="inserted">Inserted symbol</param>
 /// <returns>The inserted object</returns>
 public static object InsertObject(MathSymbol symbol, MathSymbol inserted)
 {
     return(inserted.InsertBefore(symbol.Parent, symbol));
 }
Beispiel #13
0
        /// <summary>
        /// Transformation of string representation of double values
        /// </summary>
        /// <returns>the transformation result</returns>
        public MathSymbol TranNumber()
        {
            string str = "";

            sym = Next;
            if (type != (byte)FormulaConstants.Number)
            {
                if (symbol != '.' | !s.Equals("."))
                {
                    return(sym);
                }
            }
            str += symbol;
            if (HasChildren)
            {
                if (str.Length > 2)
                {
                    if (str[1] == 'x')
                    {
                        ulong a = Hex(str);
                        ulong b = a >> 32;
                        if (b == 0)
                        {
                            doubleValue = a;
                            symbol      = '?';
                            return(sym);
                        }
                        ulongValue = a;
                        symbol     = '$';
                        return(sym);
                    }
                }
                if (!MathFormula.Resources.ContainsKey("."))
                {
                    str = str.Replace('.', DecimalSep[0]);
                }
                if (double.TryParse(str, out doubleValue))
                {
                    symbol = '?';
                }
                return(sym);
            }
            MathFormula f = new MathFormula((byte)0);

            while (true)
            {
                try
                {
                    if (sym == null)
                    {
                        if (str.Length > 2)
                        {
                            if (str[1] == 'x')
                            {
                                ulong a = Hex(str);
                                ulong b = a >> 32;
                                if (b == 0)
                                {
                                    doubleValue = a;
                                    symbol      = '?';
                                    return(sym);
                                }
                                ulongValue = a;
                                symbol     = '$';
                                return(sym);
                            }
                        }

                        str = str.Replace('.', DecimalSep[0]);
                        if (double.TryParse(str, out doubleValue))
                        {
                            symbol = '?';
                        }
                        return(sym);
                    }
                    if ((sym.type != (byte)FormulaConstants.Number) & (sym.symbol != '.'))
                    {
                        if (str.Length > 2)
                        {
                            if ((str[1] == 'x'))
                            {
                                ulong a = Hex(str);
                                ulong b = a >> 32;
                                if (b == 0)
                                {
                                    doubleValue = a;
                                    symbol      = '?';
                                    return(sym);
                                }
                                ulongValue = a;
                                symbol     = '$';
                                return(sym);
                            }
                        }
                        str         = str.Replace('.', DecimalSep[0]);
                        doubleValue = Double.Parse(str);
                        symbol      = '?';
                        return(sym);
                    }
                    if (sym.HasChildren)
                    {
                        children[0] = sym.children[0];
                        str         = str.Replace('.', DecimalSep[0]);
                        doubleValue = Double.Parse(str);
                        sym.Remove();
                        return(Next);
                    }
                    else
                    {
                        str += sym.symbol;
                        if (str.Equals(".."))
                        {
                            return(sym);
                        }
                        sym1 = sym.Next;
                        sym.Remove();
                        sym = sym1;
                    }
                }
                finally
                {
                    //throw new Exception(ERRORS[4] + ex.getMessage());
                }
            }
        }
Beispiel #14
0
 /// <summary>
 /// Replaces this symbol
 /// </summary>
 /// <param name="s">the symbol to replace</param>
 public void Replace(MathSymbol s)
 {
     Append(s);
     Remove();
 }
Beispiel #15
0
 /// <summary>
 /// Inserts symbol before this object
 /// </summary>
 /// <param name="symbol">the symbol to insert</param>
 public void Insert(MathSymbol symbol)
 {
     InsertObject(this, symbol);
 }
Beispiel #16
0
 /// <summary>
 /// Checks whether the symbol is same
 /// </summary>
 /// <param name="sym">Symbol</param>
 /// <returns>True if same and false otherwise</returns>
 public virtual bool IsSame(MathSymbol sym)
 {
     return(false);
 }