public SolutionAgg()
{
atomIndices = new IndexList();
solEq = null;
solArea = -1;
solType = SolutionType.UNKNOWN;
}
/// <exception cref="ArgumentNullException">
/// <paramref name="project"/> is null.
/// </exception>
public Generator(Project project, SolutionType type)
{
if (project == null)
throw new ArgumentNullException("project");
solutionGenerator = CreateSolutionGenerator(project, type);
}
/// <summary>
/// Konstruktor bezparametrowy na potrzeby serializacji
/// </summary>
public Solution()
{
id = null;
timeoutOccured = false;
type = SolutionType.Ongoing;
computationsTime = 0;
data = new byte[0];
}
public async Task <ActionResult> CreateSolution(SolutionType solution)
{
if (solution == null)
{
return(BadRequest());
}
await _solutionRepo.Create(solution);
return(new JsonResult("Success"));
}
/// <summary>
/// Konstruktor obiektów Solution
/// </summary>
/// <param name="_id">Id podproblemu nadane przez Task Solver</param>
/// <param name="_timeoutOccured">Czy wystąpił timeout</param>
/// <param name="_type">Typ rozwiązania</param>
/// <param name="_computationsTime">Sumaryczny czas obliczeń przez wątki</param>
/// <param name="_data">Dane rozwiązania</param>
public Solution(UInt64? _id, Boolean _timeoutOccured, SolutionType _type, UInt64 _computationsTime, byte[] _data)
{
if (_data == null)
throw new System.ArgumentNullException();
id = _id;
timeoutOccured = _timeoutOccured;
type = _type;
computationsTime = _computationsTime;
data = _data;
}
private int GetLeft(SolutionType approach, MatrixRowSummary summary)
{
switch (approach)
{
case SolutionType.EvenOut:
return(summary.Row + 1);
default:
return(default(int));
}
}
public void AddSolutionType(string TypeName, string TypeRemark)
{
SolutionType solutionType = new SolutionType
{
Type = TypeName,
Remark = (TypeRemark == null ? "无" : TypeRemark)
};
db.SolutionTypes.Add(solutionType);
db.SaveChanges();
return;
}
public Solution(string solutionName, SolutionType solutionType, int numberOfReplicates = 3)
{
SolutionName = solutionName;
SolutionType = solutionType;
NumberOfReplicates = numberOfReplicates;
for (int i = 0; i < numberOfReplicates; i++)
{
Replicates.Add(new Replicate());
}
}
public List <BuildRecord> GetAvailableBuilds(PlatformType Platform, SolutionType Solution, RoleType Role, int?FirstBuildsCount = null)
{
var FilterBuilder = new FilterDefinitionBuilder <BuildRecord>();
var Filter = FilterBuilder.Eq("Platform", Platform.ToString()) &
FilterBuilder.Eq("Solution", Solution.ToString()) &
FilterBuilder.Eq("GameType", Role.ToString());
var SortObj = Builders <BuildRecord> .Sort.Descending("datetime");
var AvailableBuilds = SelectAvailableBuildsSortedAndLimited(Filter, SortObj, FirstBuildsCount);
return(AvailableBuilds);
}
private int GenerateTreeFromMatrix(SolutionType solutionType, List <RowTree> trees, int i, ushort[,] matrix)
{
switch (solutionType)
{
case SolutionType.Sparse:
case SolutionType.Unoptimized:
trees.Add(mSlicer.SliceMatrix(i, matrix));
return(trees.Count - 1);
default:
return(-1);
}
}
public Request(SolutionType type, int ID, double allTime)
{
this.type = type;
this.ID = ID;
this.allTime = allTime;
this.curTime = this.allTime;
// acceptance = true;
// cost = 0;
// timeInQueue;
// timeProcess;
// ID++;
}
private int GenerateTreeFromArray(SolutionType solutionType, List <RowTree> trees, ushort[] input)
{
switch (solutionType)
{
case SolutionType.Sparse:
case SolutionType.Unoptimized:
trees.Add(mSlicer.SliceRow(input));
return(trees.Count - 1);
default:
return(-1);
}
}
public override Dictionary <Guid, StorePackage> GetPackages(StoreContext context)
{
Dictionary <Guid, StorePackage> packages = new Dictionary <Guid, StorePackage>();
WebClient wc = new WebClient();
string repositoryURLResolved = GetResolvedRepositoryURL(context.Web);
wc.UseDefaultCredentials = true;
wc.Encoding = Encoding.UTF8;
byte[] content = wc.DownloadData(repositoryURLResolved);
string utfString = Encoding.UTF8.GetString(content);
string repositoryXML = wc.DownloadString(repositoryURLResolved);
XmlDocument doc = new XmlDocument();
doc.LoadXml(repositoryXML);
foreach (XmlNode packageNode in doc.GetElementsByTagName("Package"))
{
StorePackage package = new StorePackage();
string title = packageNode["Title"].InnerText;
string description = packageNode["Description"].InnerText;
string id = packageNode.Attributes["ID"].InnerText;
string authorname = packageNode["AuthorName"].InnerText;
string authorURL = packageNode["AuthorURL"].InnerText;
string readmeURL = packageNode["ReadMeURL"].InnerText;
string packageURL = packageNode["PackageURL"].InnerText;
string packageFileName = packageNode["SolutionFileName"].InnerText;
string setupFeatureID = packageNode["SetupFeatureID"].InnerText;
SolutionType type = (SolutionType)Enum.Parse(typeof(SolutionType), packageNode["SolutionType"].InnerText);
package.Title = title;
package.ID = id;
package.Description = description;
package.AuthorName = authorname;
package.AuthorURL = authorURL;
package.ReadMeURL = readmeURL;
package.PackageURL = packageURL;
package.SetupFeatureID = setupFeatureID;
package.SolutionFileName = packageFileName;
package.SolutionType = type;
packages.Add(new Guid(id), package);
}
return(packages);
}
protected float GetVariableValue(Variable variable)
{
float result;
if (SolutionType.GetType() == typeof(BinaryRealSolutionType))
{
result = (float)((BinaryReal)variable).Value;
}
else
{
result = (float)((Real)variable).Value;
}
return(result);
}
private double GetVariableValue(Variable variable)
{
double result;
if (SolutionType.GetType() == typeof(BinaryRealSolutionType))
{
result = ((BinaryReal)variable).Value;
}
else
{
result = ((Real)variable).Value;
}
return(result);
}
// расчет времени на обработку заявки
double GetServiceTime(SolutionType type)
{
R = new Random();
double r = R.NextDouble();
if (type == (SolutionType)0)
{
return(-1 / (Math.Log(1 - r, Math.E)));
}
else
{
return(-1 / ((0.5 + (int)(SolutionType)type / 10) * Math.Log(1 - r, Math.E)));
}
}
public MaximumStableSet(ISolver solver, IGraph graph, Func <Node, double> weight = null)
{
Graph = graph;
if (weight == null)
{
weight = n => 1.0;
}
Weight = weight;
Problem problem = new Problem();
problem.Mode = OptimizationMode.Maximize;
foreach (Node n in graph.Nodes())
{
Variable v = problem.GetVariable(n);
v.Type = VariableType.Binary;
problem.Objective.Coefficients[v] = weight(n);
}
foreach (Arc a in graph.Arcs())
{
Node u = graph.U(a);
Node v = graph.V(a);
if (u != v)
{
problem.Constraints.Add(problem.GetVariable(u) + problem.GetVariable(v) <= 1);
}
}
Solution solution = solver.Solve(problem);
SolutionType = solution.Type;
Debug.Assert(SolutionType != SolutionType.Unbounded);
if (solution.Valid)
{
Nodes = new HashSet <Node>();
foreach (var kv in solution.Primal)
{
if (kv.Value > 0.5)
{
Node n = (Node)kv.Key.Id;
Nodes.Add(n);
}
}
}
else
{
Nodes = null;
}
}
internal static string ToSerializedValue(this SolutionType value)
{
switch (value)
{
case SolutionType.QuickSolution:
return("QuickSolution");
case SolutionType.DeepInvestigation:
return("DeepInvestigation");
case SolutionType.BestPractices:
return("BestPractices");
}
return(null);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
SolutionType = await _context.SolutionType.SingleOrDefaultAsync(m => m.SolutionTypeId == id);
if (SolutionType == null)
{
return(NotFound());
}
return(Page());
}
private static int GetBranch(SolutionType approach, MatrixRowSummary summary)
{
switch (approach)
{
case SolutionType.DeadEnd:
case SolutionType.Redirect:
return(summary.Clusters[0].First);
case SolutionType.EvenAll:
case SolutionType.EvenOut:
return(summary.Row);
default:
return(default(int));
}
}
public MatrixRowSolution SetupPrimaryLevel(
SolutionType solutionType,
MatrixRowSummary summary,
ushort rowDenominator,
int treeIndex)
{
return(new MatrixRowSolution
{
Approach = solutionType,
RowDenominator = rowDenominator,
Branch = GetBranch(solutionType, summary),
Left = GetLeft(solutionType, summary),
Domain = GetDomain(solutionType, summary),
Tree = treeIndex,
});
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
SolutionType = await _context.SolutionType.FindAsync(id);
if (SolutionType != null)
{
_context.SolutionType.Remove(SolutionType);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
/// <summary>
/// Run a specific solution for a given day.
/// </summary>
/// <param name="day">The day.</param>
/// <param name="type">The solution type.</param>
/// <param name="part">The solution part.</param>
public static void Run(int day, SolutionType type, int part)
{
var solutionType = types[day];
var classAttribute = SolutionClassAttribute.GetAttribute(solutionType);
var instance = Activator.CreateInstance(solutionType);
var methods = solutionType.GetMethods()
.Where(m => SolutionMethodAttribute.GetAttribute(m) != null)
.ToDictionary(x => SolutionMethodAttribute.GetAttribute(x).Part);
if (methods.ContainsKey(part))
{
methods[part].Invoke(instance, null);
}
}
private double[] GetVariableValues(Solution solution)
{
double[] x = new double[3];
if (SolutionType.GetType() == typeof(BinaryRealSolutionType))
{
x[0] = ((BinaryReal)solution.Variable[0]).Value;
x[1] = ((BinaryReal)solution.Variable[1]).Value;
x[2] = ((BinaryReal)solution.Variable[2]).Value;
}
else
{
x[0] = ((Real)solution.Variable[0]).Value;
x[1] = ((Real)solution.Variable[1]).Value;
x[2] = ((Real)solution.Variable[2]).Value;
}
return(x);
}
public override void SetObjectData()
{
base.SetObjectData();
int persistedClassVersion = (int)info.GetValue("ClassPersistenceVersionDryingMaterial", typeof(int));
if (persistedClassVersion == 1)
{
this.name = (string)info.GetValue("Name", typeof(string));
this.isUserDefined = (bool)info.GetValue("IsUserDefined", typeof(bool));
this.absoluteDryMaterial = CompositeSubstance.RecallSubstance(info);
this.moisture = Substance.RecallSubstance(info, "MoistureName");
this.materialType = (MaterialType)info.GetValue("MaterialType", typeof(MaterialType));
this.solutionType = (SolutionType)info.GetValue("SolutionType", typeof(SolutionType));
this.duhringLines = (CurveF[])RecallArrayObject("DuhringLines", typeof(CurveF[]));
}
}
private void btnGenerate_Click(object sender, EventArgs e)
{
if (project != null)
{
ValidateSettings();
try
{
SolutionType solutionType = (SolutionType)cboSolutionType.SelectedIndex;
Generator generator = new Generator(project, solutionType);
string destination = txtDestination.Text;
GenerationResult result = generator.Generate(destination, chkSortUsing.Checked, chkXMLDocFood.Checked, Settings.Default.CompagnyName, Settings.Default.CopyrightHeader, Settings.Default.Author);
if (result == GenerationResult.Success)
{
if (object.Equals(cboLanguage.SelectedItem, "C# extented"))
{
// TO DO : ICSharpCode.NRefactory.CSharp. FormattingOptionsFactory
// TO DO : Merge old and new files!
}
MessageBox.Show(Strings.CodeGenerationCompleted,
Strings.CodeGeneration, MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
else if (result == GenerationResult.Error)
{
MessageBox.Show(Strings.CodeGenerationFailed,
Strings.Error, MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
else // Cancelled
{
this.DialogResult = DialogResult.None;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, Strings.UnknownError,
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
private int GetDomain(SolutionType approach, MatrixRowSummary summary)
{
switch (approach)
{
case SolutionType.EvenAll:
{
return(Solver.WrapRange(0, summary.NoOfNonZeroPercents - 1, summary.NoOfStates));
}
case SolutionType.EvenOut:
return(Solver.WrapRange(
summary.Row + 1,
summary.Row - 1,
summary.NoOfStates));
default:
return(default(int));
}
}
public ShenzhenTypes(ModuleDefinition module)
{
Module = module;
BuiltIn = module.TypeSystem;
GameLogic = new GameLogicType(module);
Globals = new GlobalsType(module);
Index2 = new Index2Type(module);
L = new LType(module);
MessageThread = new MessageThreadType(module);
MessageThreads = new MessageThreadsType(module);
Optional = new OptionalType(module);
Puzzle = new PuzzleType(module);
Puzzles = new PuzzlesType(module);
Terminal = new TerminalType(module);
TextureManager = new TextureManagerType(module);
Traces = new TracesType(module);
Solution = new SolutionType(module, Traces);
}
public ActionResult EditSolutionType(SolutionTypeViewModel solutionType)
{
if (ModelState.IsValid)
{
SolutionType type = _solutionTypeService.GetSolutionType(solutionType.ID);
type.Type = solutionType.Type.Trim();
try
{
_solutionTypeService.SaveSolutionType();
}
catch (Exception ex)
{
return(View(solutionType).WithError(ex.Message));
}
}
else
{
return(View(solutionType).WithError("Invalid Data"));
}
return(RedirectToAction("SolutionTypes").WithSuccess("Solution type " + solutionType.Type + " updated successfully."));
}
private void btnGenerate_Click(object sender, EventArgs e)
{
if (project != null)
{
ValidateSettings();
try
{
SolutionType solutionType = (SolutionType)cboSolutionType.SelectedIndex;
Generator generator = new Generator(project, solutionType);
string destination = txtDestination.Text;
GenerationResult result = generator.Generate(destination);
if (result == GenerationResult.Success)
{
MessageBox.Show(Strings.CodeGenerationCompleted,
Strings.CodeGeneration, MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
else if (result == GenerationResult.Error)
{
MessageBox.Show(Strings.CodeGenerationFailed,
Strings.Error, MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
else // Cancelled
{
this.DialogResult = DialogResult.None;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, Strings.UnknownError,
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public ActionResult CreateSolutionType(SolutionTypeViewModel solutionType)
{
if (ModelState.IsValid)
{
SolutionType newType = new SolutionType();
newType.Type = solutionType.Type.Trim();
newType.DateCreated = DateTime.Now;
try
{
_solutionTypeService.CreateSolutionType(newType);
_solutionTypeService.SaveSolutionType();
}
catch (Exception ex)
{
return(View(solutionType).WithError(ex.Message));
}
}
else
{
return(View(solutionType).WithError("Invalid data"));
}
return(RedirectToAction("SolutionTypes").WithSuccess("Solution type" + solutionType.Type + " created successfully."));
}
protected virtual SolutionGenerator CreateSolutionGenerator(Project project, SolutionType type)
{
return new VSSolutionGenerator(project, type);
}
/// <summary>
/// Konstruktor obiektów Solution
/// </summary>
/// <param name="_timeoutOccured">Czy wystąpił timeout</param>
/// <param name="_type">Typ rozwiązania</param>
/// <param name="_computationsTime">Sumaryczny czas obliczeń przez wątki</param>
/// <param name="_data">Dane rozwiązania</param>
public Solution(Boolean _timeoutOccured, SolutionType _type, UInt64 _computationsTime, byte[] _data)
: this(null, _timeoutOccured, _type, _computationsTime, _data)
{
}
public Solution(float[] fs)
{
solutions = fs; type = SolutionType.Some;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="solution">solution</param>
public XReal(Solution solution)
{
type = solution.Type;
this.solution = solution;
}
/// <exception cref="ArgumentNullException">
/// <paramref name="project"/> is null.
/// </exception>
public VSSolutionGenerator(Project project, SolutionType version) : base(project)
{
Version = version;
}
/// <exception cref="ArgumentNullException">
/// <paramref name="model"/> is null.
/// </exception>
public CSharpProjectGenerator(Model model, SolutionType solutionType) : base(model)
{
this.solutionType = solutionType;
}
public Solution(SolutionType _type)
{
type = _type;
}
internal static void Main()
{
Console.SetWindowSize(Console.LargestWindowWidth - 3, Console.LargestWindowHeight - 3);
ShowWindow(GetConsoleWindow(), 3); //maximize
ConsoleKeyInfo readKey;
Console.WriteLine("C# or F# :>");
do
{
readKey = Console.ReadKey(true);
}while (readKey.Key != ConsoleKey.C && readKey.Key != ConsoleKey.F);
SolutionType solutionType = (readKey.Key == ConsoleKey.C) ? SolutionType.C : SolutionType.F;
LoadProblems(solutionType);
do
{
Logger.Clear();
Logger.WriteLine(Yellow, "Project Euler Solutions");
Logger.WriteLine(Yellow, " http://www.projecteuler.net");
Logger.WriteLine();
Logger.WriteLine(Yellow, " Using {0}# solutions", solutionType);
Logger.WriteLine();
Logger.Write(White, "Enter problem number (l to list, c to check all): ");
string str = Console.ReadLine();
if (str == "l")
{
ListProblems();
}
else if (str == "c")
{
CheckSolutions();
}
else
{
int problemNumber;
int.TryParse(str, out problemNumber);
BaseProblem problem = StartProblem(problemNumber);
Logger.Clear();
Logger.Write(Yellow, "Problem: ");
Logger.WriteLine(White, problem.Number);
Logger.WriteLine();
Logger.WriteLine(Yellow, "Date Set");
Logger.WriteLine(White, problem.DateSet.ToLongDateString());
Logger.WriteLine();
Logger.WriteLine(Yellow, "Title");
Logger.WriteLine(White, problem.Title);
Logger.WriteLine();
Logger.WriteLine(Yellow, "Description");
Logger.WriteLine(White, problem.Description);
Logger.WriteLine();
Logger.Write(Yellow, "Expected Answer: ");
if (problem.ExpectedAnswer != null)
{
Logger.WriteLine(White, problem.ExpectedAnswer.Value);
}
else
{
Logger.WriteLine(Red, "Unknown");
}
Logger.WriteLine();
TimerBlock timer = new TimerBlock();
BaseSolution solution;
if (solutions.TryGetValue(problem.Number, out solution))
{
long answer;
using (timer.Time())
{
answer = solution.GetAnswer();
}
Logger.Write(Yellow, "Answer: ");
Logger.WriteLine(White, answer);
Logger.WriteLine();
Logger.Write(Yellow, "Time Taken: ");
Logger.WriteLine(White, timer.LastLap);
}
else
{
Logger.Write(Red, "No Solution Found");
}
}
Logger.WriteLine();
Logger.WriteLine();
Logger.WriteLine(ConsoleColor.Gray, "Press any key to continue...");
readKey = Console.ReadKey();
}while (readKey.Key != ConsoleKey.Escape);
}
/// <exception cref="ArgumentNullException">
/// <paramref name="model"/> is null.
/// </exception>
public CSharpProjectGenerator(ClassModel model, SolutionType solutionType) : base(model)
{
this.solutionType = solutionType;
}
