Example #1
0
        // Needs to be called with an uninstantiated GAMSModelInstance
        static void GUSSCall(GAMSSet dict, GAMSModelInstance mi, string solveStatement, GAMSOptions opt = null, GAMSModelInstanceOpt miOpt = null, TextWriter output = null)
        {
            List <Tuple <GAMSModifier, GAMSParameter> > modifierList = new List <Tuple <GAMSModifier, GAMSParameter> >();

            if (dict.Dim != 3)
            {
                throw new GAMSException("Dict needs to be 3-dimensional");
            }

            string  scenName   = dict.FirstRecord(new string[] { " ", "scenario", " " }).Keys[0];
            GAMSSet scenSymbol = dict.GAMSDatabase.GetSet(scenName);


            foreach (GAMSSetRecord rec in dict)
            {
                if (rec.Keys[1].ToLower() == "scenario")
                {
                    continue;
                }
                if (rec.Keys[1].ToLower() == "param")
                {
                    int modifierDim = dict.GAMSDatabase.GetParameter(rec.Keys[2]).Dim - scenSymbol.Dim;
                    if (modifierDim < 0)
                    {
                        throw new GAMSException("Dimension of " + rec.Keys[2] + " too small");
                    }
                    modifierList.Add(new Tuple <GAMSModifier, GAMSParameter>
                                         (new GAMSModifier(mi.SyncDB.AddParameter(rec.Keys[0], modifierDim, "")),
                                         dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                }
                else if ((rec.Keys[1].ToLower() == "lower") || (rec.Keys[1].ToLower() == "upper") || (rec.Keys[1].ToLower() == "fixed"))
                {
                    int modifierDim = dict.GAMSDatabase.GetParameter(rec.Keys[2]).Dim - scenSymbol.Dim;
                    if (modifierDim < 0)
                    {
                        throw new GAMSException("Dimension of " + rec.Keys[2] + " too small");
                    }
                    GAMSVariable modifierVar;
                    try
                    {
                        modifierVar = dict.GAMSDatabase.GetVariable(rec.Keys[0]);
                    }
                    catch (Exception)
                    {
                        modifierVar = mi.SyncDB.AddVariable(rec.Keys[0], modifierDim, VarType.Free, "");
                    }
                    if (rec.Keys[1].ToLower() == "lower")
                    {
                        modifierList.Add(new Tuple <GAMSModifier, GAMSParameter>
                                             (new GAMSModifier(modifierVar, UpdateAction.Lower, mi.SyncDB.AddParameter(rec.Keys[2], modifierDim, "")),
                                             dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                    }
                    else if (rec.Keys[1].ToLower() == "upper")
                    {
                        modifierList.Add(new Tuple <GAMSModifier, GAMSParameter>
                                             (new GAMSModifier(modifierVar, UpdateAction.Upper, mi.SyncDB.AddParameter(rec.Keys[2], modifierDim, "")),
                                             dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                    }
                    else  // fixed
                    {
                        modifierList.Add(new Tuple <GAMSModifier, GAMSParameter>
                                             (new GAMSModifier(modifierVar, UpdateAction.Fixed, mi.SyncDB.AddParameter(rec.Keys[2], modifierDim, "")),
                                             dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                    }
                }
                else if ((rec.Keys[1].ToLower() == "level") || (rec.Keys[1].ToLower() == "marginal"))
                {
                    // Check that parameter exists in GAMSDatabase, will throw an exception if not
                    GAMSParameter x = dict.GAMSDatabase.GetParameter(rec.Keys[2]);
                }
                else
                {
                    throw new GAMSException("Cannot handle UpdateAction " + rec.Keys[1]);
                }
            }
            List <GAMSModifier> mL = new List <GAMSModifier>();

            foreach (Tuple <GAMSModifier, GAMSParameter> tup in modifierList)
            {
                mL.Add(tup.Item1);
            }
            mi.Instantiate(solveStatement, opt, mL.ToArray());

            List <Tuple <GAMSSymbol, GAMSParameter, string> > outList = new List <Tuple <GAMSSymbol, GAMSParameter, string> >();

            foreach (GAMSSetRecord s in scenSymbol)
            {
                foreach (Tuple <GAMSModifier, GAMSParameter> tup in modifierList)
                {
                    GAMSParameter p;
                    GAMSParameter pscen = tup.Item2;

                    if (tup.Item1.DataSym == null)
                    {
                        p = (GAMSParameter)tup.Item1.GamsSym;
                    }
                    else
                    {
                        p = tup.Item1.DataSym;
                    }

                    // Implemented SymbolUpdateType=BaseCase
                    p.Clear();

                    GAMSParameterRecord rec;
                    string[]            filter = new string[pscen.Dim];
                    for (int i = 0; i < scenSymbol.Dim; i++)
                    {
                        filter[i] = s.Keys[i];
                    }
                    for (int i = scenSymbol.Dim; i < pscen.Dim; i++)
                    {
                        filter[i] = " ";
                    }
                    try
                    {
                        rec = pscen.FirstRecord(filter);
                    }
                    catch (GAMSException)
                    {
                        continue;
                    }
                    do
                    {
                        string[] myKeys = new string[p.Dim];
                        for (int i = 0; i < p.Dim; i++)
                        {
                            myKeys[i] = rec.Keys[scenSymbol.Dim + i];
                        }
                        p.AddRecord(myKeys).Value = rec.Value;
                    } while (rec.MoveNext());
                }

                mi.Solve(GAMSModelInstance.SymbolUpdateType.BaseCase, output, miOpt);
                if (outList.Count == 0)
                {
                    foreach (GAMSSetRecord rec in dict)
                    {
                        if ((rec.Keys[1].ToLower() == "level") || (rec.Keys[1].ToLower() == "marginal"))
                        {
                            outList.Add(new Tuple <GAMSSymbol, GAMSParameter, string>(mi.SyncDB.GetSymbol(rec.Keys[0]), dict.GAMSDatabase.GetParameter(rec.Keys[2]), rec.Keys[1].ToLower()));
                        }
                    }
                }

                foreach (Tuple <GAMSSymbol, GAMSParameter, string> tup in outList)
                {
                    string[] myKeys = new string[scenSymbol.Dim + tup.Item1.FirstRecord().Keys.Length];
                    for (int i = 0; i < scenSymbol.Dim; i++)
                    {
                        myKeys[i] = s.Keys[i];
                    }

                    if ((tup.Item3 == "level") && (tup.Item1 is GAMSVariable))
                    {
                        foreach (GAMSVariableRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                            {
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            }
                            tup.Item2.AddRecord(myKeys).Value = rec.Level;
                        }
                    }
                    else if ((tup.Item3 == "level") && (tup.Item1 is GAMSEquation))
                    {
                        foreach (GAMSEquationRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                            {
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            }
                            tup.Item2.AddRecord(myKeys).Value = rec.Level;
                        }
                    }
                    else if ((tup.Item3 == "marginal") && (tup.Item1 is GAMSVariable))
                    {
                        foreach (GAMSVariableRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                            {
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            }
                            tup.Item2.AddRecord(myKeys).Value = rec.Marginal;
                        }
                    }
                    else if ((tup.Item3 == "marginal") && (tup.Item1 is GAMSEquation))
                    {
                        foreach (GAMSEquationRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                            {
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            }
                            tup.Item2.AddRecord(myKeys).Value = rec.Marginal;
                        }
                    }
                }
            }
        }
Example #2
0
        // Needs to be called with an uninstantiated GAMSModelInstance
        static void GUSSCall(GAMSSet dict, GAMSModelInstance mi, string solveStatement, GAMSOptions opt = null, GAMSModelInstanceOpt miOpt = null, TextWriter output=null)
        {
            List<Tuple<GAMSModifier, GAMSParameter>> modifierList = new List<Tuple<GAMSModifier, GAMSParameter>>();

            if (dict.Dim != 3)
                throw new GAMSException("Dict needs to be 3-dimensional");

            string scenName = dict.FirstRecord(new string[] { " ", "scenario", " " }).Keys[0];
            GAMSSet scenSymbol = dict.GAMSDatabase.GetSet(scenName);

            foreach (GAMSSetRecord rec in dict)
            {
                if (rec.Keys[1].ToLower() == "scenario")
                    continue;
                if (rec.Keys[1].ToLower() == "param")
                {
                    int modifierDim = dict.GAMSDatabase.GetParameter(rec.Keys[2]).Dim - scenSymbol.Dim;
                    if (modifierDim < 0)
                        throw new GAMSException("Dimension of " + rec.Keys[2] + " too small");
                    modifierList.Add(new Tuple<GAMSModifier, GAMSParameter>
                                         (new GAMSModifier(mi.SyncDB.AddParameter(rec.Keys[0], modifierDim, "")),
                                          dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                }
                else if ((rec.Keys[1].ToLower() == "lower") || (rec.Keys[1].ToLower() == "upper") || (rec.Keys[1].ToLower() == "fixed"))
                {
                    int modifierDim = dict.GAMSDatabase.GetParameter(rec.Keys[2]).Dim - scenSymbol.Dim;
                    if (modifierDim < 0)
                        throw new GAMSException("Dimension of " + rec.Keys[2] + " too small");
                    GAMSVariable modifierVar;
                    try
                    {
                        modifierVar = dict.GAMSDatabase.GetVariable(rec.Keys[0]);
                    }
                    catch (Exception)
                    {
                        modifierVar = mi.SyncDB.AddVariable(rec.Keys[0],modifierDim, VarType.Free, "");
                    }
                    if (rec.Keys[1].ToLower() == "lower")
                        modifierList.Add(new Tuple<GAMSModifier, GAMSParameter>
                                             (new GAMSModifier(modifierVar, UpdateAction.Lower, mi.SyncDB.AddParameter(rec.Keys[2], modifierDim, "")),
                                              dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                    else if (rec.Keys[1].ToLower() == "upper")
                        modifierList.Add(new Tuple<GAMSModifier, GAMSParameter>
                                             (new GAMSModifier(modifierVar, UpdateAction.Upper, mi.SyncDB.AddParameter(rec.Keys[2], modifierDim, "")),
                                              dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                    else  // fixed
                        modifierList.Add(new Tuple<GAMSModifier, GAMSParameter>
                                             (new GAMSModifier(modifierVar, UpdateAction.Fixed, mi.SyncDB.AddParameter(rec.Keys[2], modifierDim, "")),
                                              dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                }
                else if ((rec.Keys[1].ToLower() == "level") || (rec.Keys[1].ToLower() == "marginal"))
                {
                    // Check that parameter exists in GAMSDatabase, will throw an exception if not
                    GAMSParameter x = dict.GAMSDatabase.GetParameter(rec.Keys[2]);
                }
                else
                    throw new GAMSException("Cannot handle UpdateAction " + rec.Keys[1]);
            }
            List<GAMSModifier> mL = new List<GAMSModifier>();
            foreach (Tuple<GAMSModifier,GAMSParameter> tup in modifierList)
                mL.Add(tup.Item1);
            mi.Instantiate(solveStatement, opt, mL.ToArray());

            List<Tuple<GAMSSymbol, GAMSParameter, string>> outList = new List<Tuple<GAMSSymbol, GAMSParameter, string>>();

            foreach (GAMSSetRecord s in scenSymbol)
            {
                foreach (Tuple<GAMSModifier, GAMSParameter> tup in modifierList)
                {
                    GAMSParameter p;
                    GAMSParameter pscen = tup.Item2;

                    if (tup.Item1.DataSym == null)
                        p = (GAMSParameter)tup.Item1.GamsSym;
                    else
                        p = tup.Item1.DataSym;

                    // Implemented SymbolUpdateType=BaseCase
                    p.Clear();

                    GAMSParameterRecord rec;
                    string[] filter = new string[pscen.Dim];
                    for (int i = 0; i < scenSymbol.Dim; i++)
                        filter[i] = s.Keys[i];
                    for (int i = scenSymbol.Dim; i < pscen.Dim; i++)
                        filter[i] = " ";
                    try
                    {
                        rec = pscen.FirstRecord(filter);
                    }
                    catch (GAMSException)
                    {
                        continue;
                    }
                    do
                    {
                        string[] myKeys = new string[p.Dim];
                        for (int i = 0; i < p.Dim; i++)
                            myKeys[i] = rec.Keys[scenSymbol.Dim+i];
                        p.AddRecord(myKeys).Value = rec.Value;
                    } while (rec.MoveNext());
                }

                mi.Solve(GAMSModelInstance.SymbolUpdateType.BaseCase, output, miOpt);
                if (outList.Count == 0)
                    foreach (GAMSSetRecord rec in dict)
                        if ((rec.Keys[1].ToLower() == "level") || (rec.Keys[1].ToLower() == "marginal"))
                            outList.Add(new Tuple<GAMSSymbol, GAMSParameter, string>(mi.SyncDB.GetSymbol(rec.Keys[0]), dict.GAMSDatabase.GetParameter(rec.Keys[2]), rec.Keys[1].ToLower()));

                foreach (Tuple<GAMSSymbol, GAMSParameter, string> tup in outList)
                {
                    string[] myKeys = new string[scenSymbol.Dim + tup.Item1.FirstRecord().Keys.Length];
                    for (int i = 0; i < scenSymbol.Dim; i++)
                        myKeys[i] = s.Keys[i];

                    if ((tup.Item3 == "level") && (tup.Item1 is GAMSVariable))
                        foreach (GAMSVariableRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            tup.Item2.AddRecord(myKeys).Value = rec.Level;
                        }
                    else if ((tup.Item3 == "level") && (tup.Item1 is GAMSEquation))
                        foreach (GAMSEquationRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            tup.Item2.AddRecord(myKeys).Value = rec.Level;
                        }
                    else if ((tup.Item3 == "marginal") && (tup.Item1 is GAMSVariable))
                        foreach (GAMSVariableRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            tup.Item2.AddRecord(myKeys).Value = rec.Marginal;
                        }
                    else if ((tup.Item3 == "marginal") && (tup.Item1 is GAMSEquation))
                        foreach (GAMSEquationRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            tup.Item2.AddRecord(myKeys).Value = rec.Marginal;
                        }
                }
            }
        }