Bender | Xml and json serializer for .NET | Serialization library

Most likely, the solver is warm-starting from the previous optimization. This will happen if you just change a few parts of the model and don't construct a new model from scratch. Maybe, you can try to call Model.reset() to start a new optimization from scratch with full presolving.

It's hard to tell what you're doing without seeing the source code, though.

You could use Array.map() and Array.indexOf().

I'm unsure why I'm unable to use my PowerShell class as the type

The array subexpression operator @() returns its results as [object[]] - a type which satisfies the argument type [IEnumerable[object]] - which is why it always works when you use [object] as the type parameter for the receiving collection type.

So, what to do about that?

If the array consists only of [Thing]'s, you can explicitly cast to a more specific collection type that implements [IEnumerable[Thing]]:

In general, I'd strongly suggest not doing this at all. Blindly skipping certificate trust validation is a bad idea.

As I was (poorly) trying to explain in the comments, if you resolve the calling assembly (ie. System.Management.Automation.dll), you might be able to use that to discover version information in the initializer using reflection:

You cannot solve the same model with two algorithms simultaneously. However, it should be easy to create the same model twice and then solve it concurrently in two different threads or processes. You will have to use the threading or multiprocessing Python modules for this.

One very simple and convenient way on a Unix-like operation system (like Linux or MacOS) would be to use os.fork() to create a new process for each solve and then control them from the initial process. fork() implicitly clones the model, so it can save you some lines of programming.

1. typealias is literally for creating an "alias" (i.e. another name) for a type. You are not creating a new type, just another name for an existing type. From the Language Reference:

   Type aliases do not create new types; they simply allow a name to refer to an existing type.

   Therefore, once you declared the typealias, Graph and [String: [String]] now refers to the same type. An extension on Graph is equivalent to an extension on [String: [String]].

2. For your desired behaviour, you need to create a new type. For a Graph, I think a struct would be appropriate:

There are different formulas to calculate the relative optimality gap. It depends on the solver you use, which one is applied. Some info about this can be found in the description of the GAMS option optCR . The solver manual of the solver you use could have more details about the formula actually applied.

EDIT after question was updated:

As you wrote mymodel.objval returns the Final Solve value. If you want to see the MIP Solution value instead (as the Cplex link does it internally), you could deactivate the final solve. However, if Final Solve and MIP Solution are so much different as in your example this is often an indication for some problem (usually, they are (nearly) identical). Often, this indicates a poorly scaled model. Maybe you could improve the situation by tightening the Cplex tolerances (see Cplex options epopt, eprhs, epint) and activating aggressive scaling (Cplex option scaind 2). Activating mipkappastats (https://www.gams.com/latest/docs/S_CPLEX.html#CPLEXmipkappastats) and quality (https://www.gams.com/latest/docs/S_CPLEX.html#CPLEXquality) could give you more information. DataCheck=2 (https://www.gams.com/latest/docs/S_CPLEX.html#CPLEXdatacheck) might show some problems.

In your code you solve multiple optimization problems in parallel. This is fine but there is a catch: By default a single CPLEX instance will use as many threads as your machine has cores and will try to keep them busy. So if you solve N models in parallel, then on each core N instances of CPLEX will compete for computing resources. This is usually not a good idea since CPLEX processes are more or less completely CPU bound.

One option to speed up your code would be to avoid that multiple CPLEX threads run on the same core. For example, if you have 12 cores and run 3 solves in parallel, then make sure that each of these solves uses only 4 threads.

In order to limit the number of threads for a single solve use parameter IloCplex::Param::Threads.

We can try max with key