public void GenerateSolution(SolutionSerializationMode serializationMode = SolutionSerializationMode.Bare)
{
if (DataSource == null)
{
DataSource = new StreamReader(SourcePath);
}
InstanceLoader.Reader = DataSource;
Instance instance = InstanceLoader.LoadInstanceFile();
InstanceConverter.Instance = instance;
InstanceConverter.ConvertToProblem();
Solution solution = new Solution()
{
Instance = instance,
};
solution.GenerateSolutionFromRealData();
InstanceJsonSerializer serializer = new InstanceJsonSerializer();
if (OutputFilename == null)
{
OutputFilename = Path.GetFileNameWithoutExtension(SourcePath) + ".json";
}
serializer.Path = OutputFilename;
FileInfo file = new FileInfo(OutputFilename);
file.Directory.Create();
serializer.SerializeSolution(solution, serializationMode);
}
public IInterceptor CreateInterceptor()
{
if (string.IsNullOrEmpty(Configuration.InterceptorFactory))
{
return(null);
}
return(InstanceLoader.Load <IInterceptorFactory>(Configuration.InterceptorFactory).Create(NHConfiguration));
}
Environment parseEnvironment(string url, XElement actNode, XElement orgNode, bool loadAll)
{
Environment env = null;
// logfile.WriteLine("Parsing Environment file : " + url); logfile.Flush();
String s = readFlow(BaseDir + "/" + url);
XDocument parser = XDocument.Parse(s);
XElement root = parser.Root;
// Model model;
XElement modelNode = root.Element("Model");
if (modelNode != null)
{
string urlModel = modelNode.Attribute("url").Value;
/// StreamWriter file = new StreamWriter("log2.txt");
// file.WriteLine(" URL : " + url + " : " + BaseDir + "/" + urlModel);
// file.Flush();
// file.Close();
if (model == null)
{
model = parseModel(BaseDir + "/" + urlModel);
}
// if (model.Environments.ContainsKey(url))
// {
// env = model.Environments[url];
// }
// else
if (loadAll)
{
env = new Environment(model);
env.Url = url;
model.addEnvironment(env);
InstanceLoader instanceLoader = new InstanceLoader(agentPlateform, env, BaseDir + "/" + url, true);
System.Console.WriteLine("SIZE of env map " + model.Environments.Count + " of model :" + model.name);
if (actNode != null)
{
instanceLoader.parseInstances(agentPlateform, env, actNode.Attribute("url").Value, true);
}
if (orgNode != null)
{
instanceLoader.parseInstances(agentPlateform, env, orgNode.Attribute("url").Value, true);
}
}
}
else
{
env = null;
}
return(env);
}
public DataProviderBase CreateDataProvider()
{
System.Type type = System.Type.GetType(dataProviderName);
if (type == null)
{
throw new TestUtilException("DataProvider Type " + dataProviderName + " not found. ");
}
return((DataProviderBase)InstanceLoader.Load(type));
}
public static IConversationExpirationChecker Create(IBurrowConfig cfg)
{
string checkerName = cfg.ConversationExpirationChecker;
if (string.IsNullOrEmpty(checkerName))
{
return(new ConversationExpirationCheckerByTimeout());
}
return(InstanceLoader.Load <IConversationExpirationChecker>(checkerName));
}
private void RenderInstances(Device dev)
{
InstanceLoader.UpdateVisibility();
if (Meshes.Count == 0 || Textures.Count == 0 || InstanceDataBuffer == null || numInstances == 0)
{
return;
}
mModelInfo.BoneAnimator.OnFrame();
int counter = 0;
var shdr = Video.ShaderCollection.MDXShader;
dev.VertexDeclaration = InstanceDeclaration;
dev.SetRenderState(RenderState.VertexBlend, VertexBlend.Weights3);
foreach (VertexBuffer vb in Meshes)
{
dev.SetStreamSource(0, vb, 0, Marshal.SizeOf(typeof(Models.MDX.MdxVertex)));
dev.SetStreamSourceFrequency(0, numInstances, StreamSource.IndexedData);
dev.SetStreamSource(1, InstanceDataBuffer, 0, Marshal.SizeOf(typeof(Models.MDX.MdxInstanceData)));
dev.SetStreamSourceFrequency(1, 1, StreamSource.InstanceData);
setRenderValues(counter);
dev.Indices = Indices[counter];
shdr.SetTexture("MeshTexture", Textures[counter]);
if (mModelInfo.Passes[counter].BoneMatrices.Length == 0 || mModelInfo.Passes[counter].BoneMatrices.Length > 50)
{
shdr.SetValue("useAnimation", false);
}
else
{
shdr.SetValue <Matrix>("BoneMatrices", mModelInfo.Passes[counter].BoneMatrices);
shdr.SetValue("useAnimation", mModelInfo.Passes[counter].BoneMatrices.Length > 0);
}
shdr.DoRender((device) =>
{
dev.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, NumTriangles[counter] * 3, 0, NumTriangles[counter]);
}
);
unsetRenderValues();
++counter;
}
dev.VertexDeclaration = null;
dev.ResetStreamSourceFrequency(0);
dev.ResetStreamSourceFrequency(1);
dev.SetRenderState(RenderState.VertexBlend, VertexBlend.Disable);
}
private IWorkSpaceNameSniffer Sniffer()
{
IBurrowConfig cfg = bf.BurrowEnvironment.Configuration;
if (string.IsNullOrEmpty(cfg.WorkSpaceNameSniffer))
{
return(new WorkSpaceSnifferByAttribute());
}
else
{
return(InstanceLoader.Load <IWorkSpaceNameSniffer>(cfg.WorkSpaceNameSniffer));
}
}
/// <summary>
/// 初始化实例
/// </summary>
internal void InitInstance()
{
if (null == _dicInstances)
{
_dicInstances = new List <InstanceEntity>();
var configs = _InstanceConfig.GetAllConfigs();
for (int i = 0; i < configs.Count; i++)
{
var instance = InstanceLoader <IInstance> .GetInstance(configs[i]);
_dicInstances.Add(new InstanceEntity(configs[i].Key, instance));
}
}
}
// Measure FPTAS time, average and max error
static (List <FPTASSummary>, string instanceResult) RunFPTAS(Dataset dataset, double[] errors)
{
Console.WriteLine("{0}: starting calculating dateset {1}", DateTime.Now, dataset.GetFilePath());
var csvBuilder = new StringBuilder();
csvBuilder.AppendLine(TestResultHelper.GetFPTASHeader());
List <FPTASResult> instacesResults = new List <FPTASResult>();
for (int i = 1; i <= dataset.LastInstanceId; i++)
{
Console.WriteLine($"{DateTime.Now}::{dataset.Name}::{dataset.InstanceItemsCount}::{i}");
// Load instance
var instance = InstanceLoader.LoadInstanceAsync(dataset, i);
if (instance == null)
{
continue;
}
// Load optimal soultion
int optimalResult = InstanceLoader.LoadSolution(dataset, i);
foreach (var err in errors)
{
instacesResults.Add(RunFPAS(instance, optimalResult, csvBuilder, err));
}
}
var summaryItems = new List <FPTASSummary>();
foreach (var err in errors)
{
summaryItems.Add(GetSummaryItem(dataset, instacesResults, err));
}
return(summaryItems, csvBuilder.ToString());
}
public void GenerateInstance()
{
if (DataSource == null)
{
DataSource = new StreamReader(SourcePath);
}
InstanceLoader.Reader = DataSource;
var instance = InstanceLoader.LoadInstanceFile();
InstanceConverter.Instance = instance;
InstanceConverter.ConvertToProblem();
InstanceJsonSerializer serializer = new InstanceJsonSerializer();
if (OutputFilename == null)
{
OutputFilename = Path.GetFileNameWithoutExtension(SourcePath) + ".json";
}
serializer.Path = OutputFilename;
FileInfo file = new FileInfo(OutputFilename);
file.Directory.Create();
serializer.SerializeInstance(instance);
}
public List <MdxInstanceData> LockInstances()
{
return(InstanceLoader.LockInstances());
}
public void Unload()
{
InstanceLoader.Unload();
numInstances = 0;
}
public void RemoveInstance(uint id)
{
InstanceLoader.RemoveInstance(id);
}
/// <summary>
/// Adds an instance to the current collection.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="z"></param>
/// <param name="scale"></param>
/// <param name="rot"></param>
public uint AddInstance(float x, float y, float z, float scale, Vector3 rot)
{
return(InstanceLoader.PushInstance(new Vector3(x, y, z), scale, rot));
}
// Measure algorithms time
private static TestResult RunAlgorithms(Dataset dataSet, int measurementCount)
{
Console.WriteLine("{0}: starting calculating dateset {1}", DateTime.Now, dataSet.GetFilePath());
var csvBuilder = new StringBuilder();
csvBuilder.AppendLine(TestResultHelper.GetInstanceResultHeader());
var stopwatch = new Stopwatch();
double BFTotal = 0;
double BandBTotal = 0;
double dpTotal = 0;
double reduxTotal = 0;
double reduxErrSum = 0;
double reduxMaxErr = 0;
double greedyTotal = 0;
double greedyErrSum = 0;
double greedyMaxErr = 0;
double ftpasTotal = 0;
for (int i = 1; i <= dataSet.LastInstanceId; i++)
{
Console.WriteLine($"{DateTime.Now}::{dataSet.Name}::{dataSet.InstanceItemsCount}::{i}");
// Load instance and solution
var instance = InstanceLoader.LoadInstanceAsync(dataSet, i);
if (instance == null)
{
continue;
}
int optimalResult = InstanceLoader.LoadSolution(dataSet, i);
double bruteForceTimeAvg = 0;
double branchAndBoundTimeAvg = 0;
double dynamicProgrammingAvg = 0;
double greedyAvg = 0;
double reduxAvg = 0;
int[] greedyHeuristicResult = null;
int[] reduxHeuristicResult = null;
for (int j = 0; j < measurementCount; j++)
{
stopwatch.Reset();
// Start Brute Force
stopwatch.Start();
var bruteForceResult = BruteForce.Solve(0, instance.Weights, instance.Prices, 0, 0, instance.MaxWeight, instance.MinPrice, new int[instance.N + 1], new int[instance.N + 1]);
stopwatch.Stop();
CheckResult(instance, bruteForceResult[instance.N], optimalResult, dataSet.Name, nameof(BruteForce));
bruteForceTimeAvg += stopwatch.Elapsed.TotalMilliseconds;
stopwatch.Reset();
// Start Branch and Bound
stopwatch.Start();
var branchAndBoundResult = BranchAndBound.Solve(0, instance.Weights, instance.Prices, 0, 0, instance.MaxWeight, new int[instance.N + 1], new int[instance.N + 1]);
//BranchAndBound.Decide(0, instance.Weights, instance.Prices, 0, 0, instance.MaxWeight, 324);
stopwatch.Stop();
CheckResult(instance, branchAndBoundResult[instance.N], optimalResult, dataSet.Name, nameof(BranchAndBound));
branchAndBoundTimeAvg += stopwatch.Elapsed.TotalMilliseconds;
stopwatch.Reset();
// Start Dynamic programming
stopwatch.Start();
var dynamicProgrammingResult = DynamicProgramming.Solve(instance.Items, instance.MaxWeight);
stopwatch.Stop();
CheckResult(instance, dynamicProgrammingResult[instance.N], optimalResult, dataSet.Name, nameof(DynamicProgramming));
dynamicProgrammingAvg += stopwatch.Elapsed.TotalMilliseconds;
stopwatch.Reset();
// Start Greedy heuristic
stopwatch.Start();
greedyHeuristicResult = GreedyHeuristic.Solve(instance.Items.ToList(), instance.MaxWeight);
stopwatch.Stop();
//CheckResult(instance, greedyHeuristicResult[instance.N], optimalPrice, dataSet.Name, nameof(GreedyHeuristic));
greedyAvg += stopwatch.Elapsed.TotalMilliseconds;
stopwatch.Reset();
// Start Redux heuristic
stopwatch.Start();
reduxHeuristicResult = ReduxHeuristic.Solve(instance.Items.ToList(), instance.MaxWeight);
stopwatch.Stop();
reduxAvg += stopwatch.Elapsed.TotalMilliseconds;
stopwatch.Reset();
}
BFTotal += Avg(bruteForceTimeAvg, measurementCount);
BandBTotal += Avg(branchAndBoundTimeAvg, measurementCount);
dpTotal += Avg(dynamicProgrammingAvg, measurementCount);
greedyTotal += Avg(greedyAvg, measurementCount);
reduxTotal += Avg(reduxAvg, measurementCount);
csvBuilder.AppendLine(TestResultHelper.FormatInstanceResultRow(
instance.Id,
instance.N,
Avg(bruteForceTimeAvg, measurementCount),
Avg(branchAndBoundTimeAvg, measurementCount),
Avg(dynamicProgrammingAvg, measurementCount),
Avg(greedyAvg, measurementCount),
Avg(reduxAvg, measurementCount),
0
));
}
Console.WriteLine("{0}: calculating dataset {1} ended", DateTime.Now, dataSet.GetFilePath());
return(new TestResult
{
InstanceSize = dataSet.InstanceItemsCount,
InstancesResults = csvBuilder.ToString(),
BFTime = Avg(BFTotal, dataSet.InstancesCount),
BandBTime = Avg(BandBTotal, dataSet.InstancesCount),
GreedyHeuristicTime = Avg(greedyTotal, dataSet.InstancesCount),
ReduxHeuristicTime = Avg(reduxTotal, dataSet.InstancesCount),
DPTime = Avg(dpTotal, dataSet.InstancesCount),
FTPASTime = Avg(ftpasTotal, dataSet.InstancesCount),
GreedyRelErr = Avg(greedyErrSum, dataSet.InstancesCount),
GreedyMaxErr = greedyMaxErr,
ReduxRelErr = Avg(reduxErrSum, dataSet.InstancesCount),
ReduxMaxErr = reduxMaxErr
});
}
