コード例 #1
0
 /// <summary>
 /// Add the given multiple of mf into to.
 /// </summary>
 /// <param name="to"></param>
 /// <param name="mf"></param>
 /// <param name="multiple"></param>
 private void Add(MolecularFormula to, MolecularFormula mf, int multiple)
 {
     foreach (String s in mf.elementCounts.Keys)
     {
         to.Add(s, ((int)mf.elementCounts[s]) * multiple);
     }
 }
コード例 #2
0
 public void Add(String part, MolecularFormula mf)
 {
     if (part == null)
     {
         throw new ArgumentNullException("part");
     }
     if (mf == null)
     {
         throw new ArgumentNullException("mf");
     }
     partFormulas.Add(part, mf);
 }
コード例 #3
0
 public void Set(String part, MolecularFormula mf)
 {
     if (part == null)
     {
         throw new ArgumentNullException("part");
     }
     if (mf == null)
     {
         throw new ArgumentNullException("mf");
     }
     this.partFormulas.Remove(part);
     this.Add(part, mf);
 }
コード例 #4
0
        public MolecularFormula Add(MolecularFormula mf, int multiple, bool permitNegativeMultiple)
        {
            if (multiple < 0 && !permitNegativeMultiple)
            {
                throw new ArgumentOutOfRangeException("multiple", multiple, "Multiple must be >= 0");
            }
            var newFormula = new MolecularFormula(this);

            newFormula.name          = null;
            newFormula.formulaString = null;
            Add(newFormula, mf, multiple);
            return(newFormula);
        }
コード例 #5
0
        public static MolecularFormula Parse(String formula, String name, bool allowNegatives)
        {
            if (formula == null)
            {
                throw new ArgumentNullException("formula");
            }
            var match = parsingRegex.Match(formula);

            if (!match.Success)
            {
                throw new ApplicationException("Formula can not be parsed");
            }

            var mf      = new MolecularFormula();
            var matched = match.Groups["element"].Captures.Count;

            //Console.WriteLine("Num Groups {0}", matched);
            // Iterate through the matched groups, updating element counts
            for (var i = 0; i < matched; i++)
            {
                var element = match.Groups["element"].Captures[i].Value;
                var count   = match.Groups["count"].Captures[i].Value;
                //Console.WriteLine("Element {0}, Count {1}", element, count);
                // If the symbol is unknown, throw an exception.
                // The multiple defaults to 1 if not found.  So CHHCHH is C2 H4.
                var multiple = 1;
                if (count != "")
                {
                    try
                    {
                        multiple = int.Parse(count);
                        if (multiple < 0 && !allowNegatives)
                        {
                            throw new ApplicationException("Negative multiple " + multiple + " for element " +
                                                           element + " is not allowed.");
                        }
                    }
                    // This can never actually happen, because the regex makes sure that
                    // only integer values which can be parsed make it to this stage
                    catch (Exception ex)
                    {
                        throw new ApplicationException("The multiple for element " + element + ", " + count + ", was not parseable", ex);
                    }
                }
                mf.Add(element, multiple);
            }
            mf.formulaString = formula;
            mf.name          = name;
            return(mf);
        }
コード例 #6
0
 public MolecularFormula Translate(String input, String partRegex)
 {
     try
     {
         var regex   = new Regex(partRegex);
         var formula = new MolecularFormula();
         var matches = regex.Matches(input);
         foreach (Match match in matches)
         {
             var partFormula = (MolecularFormula)this.partFormulas[match.Value];
             if (partFormula == null)
             {
                 throw new ApplicationException("Formula for part " + match.Value + " is unknown.");
             }
             formula = formula.Add(partFormula, 1);
         }
         return(formula);
     }
     catch (Exception e)
     {
         throw new ApplicationException("Translation of " + input + " failed.  " + e.Message, e);
     }
 }
コード例 #7
0
 /// <summary>
 /// Create a new MolecularFormula by adding the given formula (times the given multiple)
 /// to this formula.
 /// </summary>
 /// <param name="mf"></param>
 /// <param name="multiple"></param>
 /// <returns></returns>
 public MolecularFormula Add(MolecularFormula mf, int multiple)
 {
     return(Add(mf, multiple, false));
 }
コード例 #8
0
 /// <summary>
 /// Clones the formula.
 /// </summary>
 /// <param name="formula"></param>
 private MolecularFormula(MolecularFormula formula)
 {
     this.name          = formula.name;
     this.formulaString = formula.formulaString;
     this.elementCounts = new Hashtable(formula.elementCounts);
 }