/// <summary>
/// Rend un axe au format CSV.
/// </summary>
/// <param name="hyperCube">HyperCube.</param>
/// <param name="context">Contexte.</param>
/// <param name="writer">Writer CSV.</param>
/// <param name="activeCounters">Compteur actifs.</param>
/// <param name="axis">Axe.</param>
private static void CreateCsvAxis(IHyperCube hyperCube, Context context, TextWriter writer, Dictionary <string, string> activeCounters, string axis)
{
CounterCubeCriteria criteria = new CounterCubeCriteria(axis, TimeLevel.Hour);
CubeKey key = criteria.CreateCubeKey(context.EndDate);
ICube cube = hyperCube.GetCube(key);
if (cube != null && IsShown(context.EndDate, context.Filtre, hyperCube, criteria))
{
writer.Write(axis);
writer.Write(";");
double total = cube.GetCounter(Analytics.ElapsedTime).GetValue(CounterStatType.Total);
writer.Write(Convert.ToString(total, CultureInfo.CurrentCulture));
writer.Write(";");
double hits = cube.GetCounter(Analytics.ElapsedTime).GetValue(CounterStatType.Hits);
writer.Write(Convert.ToString(hits, CultureInfo.CurrentCulture));
writer.Write(";");
double avg;
foreach (ICounterDefinition definition in hyperCube.AllDefinitions)
{
if (activeCounters.ContainsKey(definition.Code))
{
ICounter counter = cube.GetCounter(definition.Code);
avg = (counter != null) ? counter.GetValue(CounterStatType.Avg) : 0;
writer.Write(string.Format(CultureInfo.CurrentCulture, "{0:0.##}", avg));
writer.Write(";");
}
}
writer.WriteLine();
}
}
/// <summary>
/// Retourne la liste de tous les axes d'un hypercybe trié sur la valeur moyen d'un compteur.
/// </summary>
/// <param name="date">Date des valeurs.</param>
/// <param name="hyperCube">Hybercube contenant les valeurs.</param>
/// <param name="sort">Compteur de tri.</param>
/// <returns>Liste des axes triés sur un compteur.</returns>
private static List <string> GetAllAxis(DateTime date, IHyperCube hyperCube, string sort)
{
ICollection <string> allAxis = hyperCube.AllAxis;
if (sort == null)
{
// On crée une nouvelle liste pour pouvoir la trier sans toucher à l'originale.
List <string> list = new List <string>(allAxis);
// On trie cette liste par ordre alphabétique
list.Sort();
return(list);
}
else if ("HITS".Equals(sort))
{
return(SortAllAxis(hyperCube, allAxis, date, Analytics.ElapsedTime, CounterStatType.Hits));
}
else if ("TOTAL".Equals(sort))
{
return(SortAllAxis(hyperCube, allAxis, date, Analytics.ElapsedTime, CounterStatType.Total));
}
else if (Analytics.ElapsedTime.Equals(sort))
{
return(SortAllAxis(hyperCube, allAxis, date, Analytics.ElapsedTime, CounterStatType.Avg));
}
else
{
return(SortAllAxis(hyperCube, allAxis, date, sort, CounterStatType.Avg));
}
}
public static void TestAreEqual(double[] values, IHyperCube <double> point, string[] varNames, double delta = 1e-12)
{
for (int i = 0; i < varNames.Length; i++)
{
Assert.AreEqual(values[i], point.GetValue(varNames[i]), delta, "variable " + varNames[i]);
}
}
public IHyperCube<double> GenerateRandomWithinHypercube( IHyperCube<double>[] points )
{
if( points.Length == 0 )
{
return this.GenerateRandom(points[0]);
}
else
{
IHyperCube<double> p = points[0].Clone() as IHyperCube<double>;
string[] varNames = p.GetVariableNames();
for (int i = 0; i < varNames.Length; i++)
{
string v = varNames[i];
double minimum;
double maximum;
GetSmallestIntervalForValues(points, v, out minimum, out maximum);
minimum = Math.Max(minimum, p.GetMinValue(v));
maximum = Math.Min(maximum, p.GetMaxValue(v));
checkFeasibleInterval(minimum, maximum, v);
p.SetValue(varNames[i], GetRandomisedValue(minimum, maximum));
}
return p;
}
}
public IHyperCube <double> GetCentroid(IHyperCube <double>[] points)
{
if (points == null)
{
return(null);
}
if (points.Length == 1)
{
return(points[0].Clone( ) as IHyperCube <double>);
}
IHyperCube <double> p = points[0].Clone( ) as IHyperCube <double>;
string[] varNames = p.GetVariableNames();
foreach (string varName in varNames)
{
double val = 0.0;
for (int i = 0; i < points.Length; i++)
{
val += points[i].GetValue(varName);
}
p.SetValue(varName, val / ((double)points.Length));
}
return(p);
}
public IHyperCube<double> GetCentroid( IHyperCube<double>[] points )
{
if( points == null )
{
return null;
}
if( points.Length == 1 )
{
return points[0].Clone( ) as IHyperCube<double>;
}
IHyperCube<double> p = points[0].Clone( ) as IHyperCube<double>;
string[] varNames = p.GetVariableNames();
foreach( string varName in varNames )
{
double val = 0.0;
for( int i = 0; i < points.Length; i++ )
{
val += points[i].GetValue(varName);
}
p.SetValue( varName, val / ( (double)points.Length ) );
}
return p;
}
public void Write(IHyperCube <double> newPoint, IDictionary <string, string> tags)
{
if (log.IsInfoEnabled)
{
log.Info(new SysConfigLogInfo(LoggerMhHelper.CreateNoScore(newPoint), tags));
}
}
/// <summary>
/// Rend un compteur sous forme HTML.
/// </summary>
/// <param name="hyperCube">Hypercube contenant les données.</param>
/// <param name="writer">Writer HTML.</param>
/// <param name="counter">Compteur.</param>
/// <param name="counterDefinition">Définition du compteur.</param>
/// <param name="link">Indique si un lien doit être créé pour la selection des graphiques.</param>
/// <param name="context">Context courant de la requête.</param>
private static void ToHtml(IHyperCube hyperCube, HtmlTextWriter writer, ICounter counter, ICounterDefinition counterDefinition, bool link, Context context)
{
StatToHtml(hyperCube, writer, counter, counterDefinition, link, context, CounterStatType.Last);
StatToHtml(hyperCube, writer, counter, counterDefinition, link, context, CounterStatType.Avg);
StatToHtml(hyperCube, writer, counter, counterDefinition, link, context, CounterStatType.Min);
StatToHtml(hyperCube, writer, counter, counterDefinition, link, context, CounterStatType.Max);
}
public ControlFileCreator(
IHyperCube <double> StartingPoint,
String CommandLineExecutable,
String TemplateFile,
String ParameterFile,
String InstructionFile,
String ResultFile,
ModelRunner mr,
String ControlFile,
TimeSeries ObservationData,
int Iterations,
string controlSettings
)
{
this.startingPoint = StartingPoint;
this.commandLineExecutable = CommandLineExecutable;
this.templateFile = TemplateFile;
this.parameterFile = ParameterFile;
this.instructionFile = InstructionFile;
this.resultFile = ResultFile;
this.controlFile = ControlFile;
this.NumberOfIterations = Iterations;
this.xmlSettingsFile = controlSettings;
modelRunner = mr;
this.observedTimeSeries = ObservationData;
}
public IHyperCube <double> GenerateRandomWithinHypercube(IHyperCube <double>[] points)
{
if (points.Length == 0)
{
return(this.GenerateRandom(points[0]));
}
else
{
IHyperCube <double> p = points[0].Clone() as IHyperCube <double>;
string[] varNames = p.GetVariableNames();
for (int i = 0; i < varNames.Length; i++)
{
string v = varNames[i];
double minimum;
double maximum;
GetSmallestIntervalForValues(points, v, out minimum, out maximum);
minimum = Math.Max(minimum, p.GetMinValue(v));
maximum = Math.Min(maximum, p.GetMaxValue(v));
checkFeasibleInterval(minimum, maximum, v);
p.SetValue(varNames[i], GetRandomisedValue(minimum, maximum));
}
return(p);
}
}
public IHyperCube <double> HomotheticTransform(IHyperCube <double> point, double factor)
{
var p = point as MpiSysConfig;
var result = (MpiSysConfig)this.Clone();
//return performMirrorBounceTransform(factor, p, result);
return(performDefaultTransform(factor, p, result));
}
/// <summary>
/// Constructeur.
/// </summary>
/// <param name="hyperCube">HyperCube utilisé par le comparateur.</param>
/// <param name="date">Date à la quelle se fait la comparaison.</param>
/// <param name="counterDefinitionCode">Compteur à comparer.</param>
/// <param name="statType">Type de statistique à comparer (min, max, moy, ...).</param>
/// <param name="level">Période de temps sur laquelle appliquer la comparaison.</param>
internal HyperCubeComparer(IHyperCube hyperCube, DateTime date, string counterDefinitionCode, CounterStatType statType, TimeLevel level)
{
this._counterDefinitionCode = counterDefinitionCode;
this._date = date;
this._hyperCube = hyperCube;
this._level = level;
this._statType = statType;
}
/// <summary>
/// Réalise le rendu HTML contenant les sparklines du nombre de hits sur les
/// 10 dernières minutes.
/// </summary>
/// <param name="hyperCube">Hypercube contenant les valeurs.</param>
/// <param name="criteria">Critère de rendu (axe courant, date, période de temps).</param>
/// <param name="writer">Writer HTML.</param>
/// <param name="context">Context courant de la requête.</param>
private static void PrintChartSparkLines(IHyperCube hyperCube, CounterCubeCriteria criteria, HtmlTextWriter writer, Context context)
{
string url = context.ChangeSort(null).GetHandlerUrl() + "&CONTENT=sparklines.png&MON_ID=" + hyperCube.Name + "&LEVEL=" + criteria.Level;
writer.Write("<td class=\"monitoring\" align=\"right\">");
writer.Write("<img src=\"" + url + "\"/>");
writer.WriteLine("</td>");
}
public override IHyperCube <double> HomotheticTransform(IHyperCube <double> point, double factor)
{
var pt = point as TestHyperCube;
HyperCube <double> result = new TestHyperCube(this.Dimensions);
performHomoteticTransform(point, factor, ref result);
return(result);
}
public IObjectiveScores <IHyperCube <double> > EvaluateScore(IHyperCube <double> systemConfiguration)
{
apply(systemConfiguration, simulation);
simulation.Execute();
double result = sumSquares(simulation.GetRecorded("Runoff"), this.observedData);
return(MetaheuristicsHelper.CreateSingleObjective(systemConfiguration, result, "Sum Squares"));
}
/// <summary>
/// Tri une liste.
/// </summary>
/// <param name="hyperCube">Hybercube contenant les éléments de la liste.</param>
/// <param name="allAxis">Liste des axes.</param>
/// <param name="date">Date des valeurs à trier.</param>
/// <param name="counterDefinitionCode">Compteur à trier.</param>
/// <param name="statType">Type de statistique à trier.</param>
/// <returns>Liste triée par ordre croissant des valeurs sur les axes.</returns>
private static List <string> SortAllAxis(IHyperCube hyperCube, ICollection <string> allAxis, DateTime date, string counterDefinitionCode, CounterStatType statType)
{
// On crée une nouvelle liste pour pouvoir la trier sans toucher à l'originale.
List <string> countersList = new List <string>(allAxis);
countersList.Sort(new HyperCubeComparer(hyperCube, date, counterDefinitionCode, statType, TimeLevel.Hour));
return(countersList);
}
public override IHyperCube <double> HomotheticTransform(IHyperCube <double> point, double factor)
{
var pt = point as BasicHyperCube;
HyperCube <double> result =
(BasicHyperCube)this.Clone();
performHomoteticTransform(point, factor, ref result);
return(result);
}
private void apply(IHyperCube <double> systemConfiguration, IModelSimulation <double[], double, int> simulation)
{
var varNames = systemConfiguration.GetVariableNames();
foreach (var varName in varNames)
{
simulation.SetVariable(varName, systemConfiguration.GetValue(varName));
}
}
/// <summary>
/// Crée un axe en HTML.
/// </summary>
/// <param name="hyperCube">Cube.</param>
/// <param name="context">Contexte.</param>
/// <param name="writer">Writer HTML.</param>
/// <param name="requestName">Nom de la requête.</param>
/// <param name="activeCounters">Compteurs actifs.</param>
/// <param name="odd">Parité.</param>
/// <param name="axis">Axe.</param>
/// <param name="criteria">Critères.</param>
/// <param name="cube">Cube.</param>
private static void CreateHtmlAxis(IHyperCube hyperCube, Context context, HtmlTextWriter writer, string requestName, Dictionary <string, string> activeCounters, bool odd, string axis, CounterCubeCriteria criteria, ICube cube)
{
writer.Write(HtmlPageRenderer.Indent);
writer.WriteLine("<tr " + (odd ? "class=\"odd\"" : string.Empty) + '>');
writer.Write(HtmlPageRenderer.Indent2);
writer.Write("<td class=\"monitoring\">");
Context localContext = context.Zoom(hyperCube.Name, axis);
writer.Write(HtmlPageRenderer.GetLink(localContext, axis, !axis.Equals(requestName)));
writer.WriteLine("</td>");
writer.Write(HtmlPageRenderer.Indent2);
writer.Write("<td class=\"monitoring\" align=\"right\">");
double total = cube.GetCounter(Analytics.ElapsedTime).GetValue(CounterStatType.Total);
writer.Write(Convert.ToString(total, CultureInfo.CurrentCulture));
writer.WriteLine("</td>");
writer.Write(HtmlPageRenderer.Indent2);
double avg = cube.GetCounter(Analytics.ElapsedTime).GetValue(CounterStatType.Avg);
writer.Write("<td class=\"monitoring\" align=\"right\" "
+ GetHtmlStyle(1000, 10000, avg) + '>');
writer.Write(string.Format(CultureInfo.CurrentCulture, "{0:0.##}", avg));
writer.WriteLine("</td>");
writer.Write(HtmlPageRenderer.Indent2);
writer.Write("<td class=\"monitoring\" align=\"right\">");
double hits = cube.GetCounter(Analytics.ElapsedTime).GetValue(CounterStatType.Hits);
writer.Write(Convert.ToString(hits, CultureInfo.CurrentCulture));
writer.WriteLine("</td>");
writer.Write(HtmlPageRenderer.Indent2);
PrintChartSparkLines(hyperCube, new CounterCubeCriteria(axis, TimeLevel.Minute), writer, localContext);
double midValue;
foreach (ICounterDefinition counterDefinition in hyperCube.AllDefinitions)
{
if (activeCounters.ContainsKey(counterDefinition.Code))
{
ICounter counter = hyperCube.GetCube(criteria.CreateCubeKey(context.EndDate)).GetCounter(counterDefinition.Code);
midValue = (counter != null) ? counter.GetValue(CounterStatType.Avg) : 0;
writer.Write(HtmlPageRenderer.Indent2);
writer.Write("<td class=\"monitoring\" align=\"right\" "
+ GetHtmlStyle(counterDefinition, midValue) + '>');
writer.Write(string.Format(CultureInfo.CurrentCulture, "{0:0.##}", midValue));
writer.WriteLine("</td>");
}
}
writer.Write(HtmlPageRenderer.Indent);
writer.WriteLine("</tr>");
}
public static void TestCentroidCalculation(HyperCubeOperations hco, IHyperCube <double> hc_1, IHyperCube <double> hc_2, IHyperCube <double> hc_3, string[] varNames)
{
IHyperCube <double>[] points = new IHyperCube <double>[] { hc_1, hc_2, hc_3 };
var centroid = hco.GetCentroid(points);
//[0,0,0]
//[1,0,0]
//[0,2,0]
TestAreEqual(new double[] { 1 / 3.0, 2 / 3.0, 0 }, centroid, varNames);
}
public IHyperCube <double> HomotheticTransform(IHyperCube <double> point, double factor)
{
var p = point as UnivariateReal;
var result = new UnivariateReal(p.value + factor * (this.value - p.value));
if (result.value > result.max || result.value < result.min)
{
return(null);
}
return(result);
}
/// <summary>
/// Réalise le rendu du résumé d'un hypercube.
/// </summary>
/// <param name="hyperCube">Hypercube à rendre.</param>
/// <param name="context">Context courant de la requête.</param>
/// <param name="writer">Writer HTML.</param>
internal static void ToSummary(IHyperCube hyperCube, Context context, HtmlTextWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
string requestName = context.GetRequestName(hyperCube.Name);
writer.WriteLine("<ul>");
writer.Write("<li>");
writer.WriteLine(HtmlPageRenderer.GetLink(context, "Rafraîchir", true));
writer.WriteLine("</li>");
if (hyperCube.IsResetable)
{
writer.Write("<li>");
writer.WriteLine(HtmlPageRenderer.GetLink(context.Reset(hyperCube.Name), "Remettre à zéro", true));
writer.WriteLine("</li>");
}
// Si on est sur une page locale on rend accès aux statistiques globales
if (requestName != null)
{
writer.Write("<li>");
writer.WriteLine(HtmlPageRenderer.GetLink(context.Zoom(null, null), "Statistiques globales", true));
writer.WriteLine("</li>");
}
writer.WriteLine("</ul>");
Context targetContext;
if (requestName == null)
{
writer.Write("<h2>Statistiques globales</h2>");
targetContext = context;
}
else
{
writer.Write("<h2>Statistiques pour ");
writer.Write(requestName);
writer.WriteLine("</h2>");
targetContext = context.Zoom(null, null);
}
ICube cube = hyperCube.GetCube(new CounterCubeCriteria(requestName, TimeLevel.Hour).CreateCubeKey(context.EndDate));
if (cube != null)
{
// On affiche les données relative au cube
bool link = requestName == null; // Si pas de request précisé on met les liens.
RenderCube(hyperCube, cube, writer, link, targetContext);
}
}
/// <summary>
/// Réalise le rendu du contrôle.
/// </summary>
/// <param name="writer">Writer HTML.</param>
public override void RenderControl(HtmlTextWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
Context ctx = new Context(HttpContext.Current, this.ResolveUrl(this.HandlerPath));
ctx.ClearAction();
foreach (string param in _params.Keys)
{
ctx.AddParam(param, _params[param]);
}
writer.AddAttribute(HtmlTextWriterAttribute.Id, "managers");
writer.RenderBeginTag(HtmlTextWriterTag.Div);
SortedDictionary <int, string> sortMap = new SortedDictionary <int, string>();
foreach (string databaseName in _databaseSet.DatabaseNames)
{
IManagerDescription description = this.DatabaseDefinition[databaseName];
sortMap.Add(description.Priority, databaseName);
}
foreach (int priority in sortMap.Keys)
{
string databaseName = sortMap[priority];
IManagerDescription description = this.DatabaseDefinition[databaseName];
writer.AddAttribute(HtmlTextWriterAttribute.Id, "manager");
writer.RenderBeginTag(HtmlTextWriterTag.Div);
writer.WriteLine("<h1 style=\"background-image: url('" + this.ResolveUrl(this.HandlerPath) + "?CONTENT=img_manager&MON_ID=" +
description.Image + "');\">");
writer.WriteLine(description.Name);
writer.WriteLine("</h1>");
writer.WriteLine("<div id=\"description\">");
IHyperCube hyperCube = _databaseSet.GetDatabase(databaseName);
HtmlPageHelper.ToSummary(hyperCube, ctx, writer);
HtmlPageHelper.ToTable(hyperCube, ctx, writer);
writer.WriteLine("</div>"); // description
writer.RenderEndTag();
}
writer.RenderEndTag();
}
public static double CalculateParaboloid(IHyperCube <double> sysConfig, double bestParam)
{
var names = sysConfig.GetVariableNames();
double result = 0;
for (int i = 0; i < names.Length; i++)
{
var name = names[i];
double v = (sysConfig.GetValue(name) - bestParam);
result += v * v;
}
return(result);
}
private string createPESTFiles(
IHyperCube <double> startingPoint,
String outputFolder,
TimeSeries observedTimeSeries,
string modelOutputName,
string PestToMetaheuristicsCommandLine,
ModelRunner modelRunner,
int Iterations,
string controlSettings,
out string resultFile
)
{
String templateFile;
String instructionFile;
String controlFile;
String parameterFile;
String calculatedResultFile;
createFileNames(outputFolder, out templateFile, out instructionFile, out controlFile, out parameterFile, out calculatedResultFile);
const int precision = 23;
// create the three files using the helper classes
TemplateFileCreator templateCreator = new TemplateFileCreator(templateFile, modelRunner, precision, PESTDELIMITER);
templateCreator.CreateFile();
InstructionFileCreator instructionCreator = new InstructionFileCreator(observedTimeSeries, instructionFile);
instructionCreator.CreateFile();
ControlFileCreator controlCreator =
new ControlFileCreator(
startingPoint,
PestToMetaheuristicsCommandLine,
templateFile,
parameterFile,
instructionFile,
calculatedResultFile,
modelRunner,
controlFile,
observedTimeSeries,
Iterations,
controlSettings
);
controlCreator.CreateFile();
resultFile = calculatedResultFile;
return(controlFile);
}
/// <summary>
/// Réalise le rendu d'un cude.
/// </summary>
/// <param name="hyperCube">HyperCupe à rendre.</param>
/// <param name="context">Context courant de la requête.</param>
/// <param name="s">Stream de sortie.</param>
internal static void RenderGraph(IHyperCube hyperCube, Context context, Stream s)
{
TimeLevel level = TimeLevel.ValueOf(context.Level);
CounterCubeCriteria criteria = new CounterCubeCriteria(context.RequestName, level);
if (context.Content.Equals("sparklines.png"))
{
HtmlGraphHelper.RenderGraphSparklines(context, hyperCube, criteria, s);
}
else
{
throw new NotSupportedException();
}
}
public IHyperCube <double> HomotheticTransform(IHyperCube <double> point, double factor)
{
var centralPoint = (UnivariateReal)point;
var reflectedValue = centralPoint.value + (this.value - centralPoint.value) * factor;
if (reflectedValue > this.maxValue || reflectedValue < this.minValue)
{
return(null);
}
var result = (UnivariateReal)this.MemberwiseClone( );
result.SetValue(this.VariableName, reflectedValue);
return(result);
}
public static bool CheckInBounds <T>(IHyperCube <T> point) where T : IComparable
{
foreach (var varName in point.GetVariableNames())
{
var min = point.GetMinValue(varName);
var max = point.GetMaxValue(varName);
var val = point.GetValue(varName);
if (!MetaheuristicsHelper.CheckInBounds(val, min, max, throwIfFalse: false))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Rend une statistique au format HTML.
/// </summary>
/// <param name="hyperCube">Hypercube contenant les données.</param>
/// <param name="writer">Writer HTML.</param>
/// <param name="counter">Compteur.</param>
/// <param name="counterDefinition">Définition du compteur.</param>
/// <param name="link">Indique si un lien doit être créé pour la selection des graphiques.</param>
/// <param name="context">Contexte courant de la requête.</param>
/// <param name="counterStatType">Type de statistique du compteur à rendre.</param>
private static void StatToHtml(IHyperCube hyperCube, HtmlTextWriter writer, ICounter counter, ICounterDefinition counterDefinition, bool link, Context context, CounterStatType counterStatType)
{
writer.Write(HtmlPageRenderer.Indent2);
writer.Write("<td class=\"monitoring\" align=\"right\" " + GetHtmlStyle(counterDefinition, counter.GetValue(counterStatType)) + '>');
writer.Write(string.Format(CultureInfo.CurrentCulture, "{0:0.##}", counter.GetValue(counterStatType)));
writer.WriteLine("</td>");
if (counter.HasInfo(counterStatType))
{
writer.Write(HtmlPageRenderer.Indent2);
writer.Write("<td class=\"monitoring\">");
writer.Write(HtmlPageRenderer.GetLink(context.Zoom(hyperCube.Name, counter.GetInfo(counterStatType)), counter.GetInfo(counterStatType), link));
writer.WriteLine("</td>");
}
}
public IHyperCube<double> GenerateRandom( IHyperCube<double> point )
{
string[] varNames = point.GetVariableNames( );
IHyperCube<double> result = point.Clone( ) as IHyperCube<double> ;
for( int i = 0; i < varNames.Length; i++ )
{
string v = varNames[i];
// We take the bounds of the result point, to cater for cascading parameter constraints.
double min = result.GetMinValue(v);
double max = result.GetMaxValue(v);
checkFeasibleInterval(min, max, v);
result.SetValue( varNames[i], GetRandomisedValue(min, max) );
}
return result;
}
/// <summary>
/// Réalise le rendu d'une base au format CSV.
/// </summary>
/// <param name="hyperCube">Hypercube contenant les valeurs.</param>
/// <param name="context">Contexte de la requête.</param>
/// <param name="writer">Writer.</param>
internal static void ToCsv(IHyperCube hyperCube, Context context, TextWriter writer)
{
string requestName = context.GetRequestName(hyperCube.Name);
List <string> axisList = GetAllAxis(context.EndDate, hyperCube, context.Sort);
writer.Write("Requete;");
writer.Write("total;");
writer.Write("hits;");
Dictionary <string, string> activeCounters = RenderLabels(writer, hyperCube, context, requestName);
foreach (string axis in axisList)
{
CreateCsvAxis(hyperCube, context, writer, activeCounters, axis);
}
}
public static HyperCubeInterop ToDataFrame(IHyperCube <double> paramSet)
{
var names = paramSet.GetVariableNames();
var r = new HyperCubeInterop(names.Length);
for (int i = 0; i < names.Length; i++)
{
var name = names[i];
r.Name[i] = name;
r.Description[i] = "";
r.Value[i] = paramSet.GetValue(name);
r.Min[i] = paramSet.GetMinValue(name);
r.Max[i] = paramSet.GetMaxValue(name);
}
return(r);
}
public IHyperCube <double> GenerateRandom(IHyperCube <double> point)
{
string[] varNames = point.GetVariableNames( );
IHyperCube <double> result = point.Clone( ) as IHyperCube <double>;
for (int i = 0; i < varNames.Length; i++)
{
string v = varNames[i];
// We take the bounds of the result point, to cater for cascading parameter constraints.
double min = result.GetMinValue(v);
double max = result.GetMaxValue(v);
checkFeasibleInterval(min, max, v);
result.SetValue(varNames[i], GetRandomisedValue(min, max));
}
return(result);
}
public void Write(IHyperCube<double> newPoint, IDictionary<string, string> tags)
{
if (log.IsInfoEnabled)
log.Info(new SysConfigLogInfo(LoggerMhHelper.CreateNoScore(newPoint), tags));
}
public static HyperCubeInterop ToDataFrame(IHyperCube<double> paramSet)
{
var names = paramSet.GetVariableNames();
var r = new HyperCubeInterop(names.Length);
for (int i = 0; i < names.Length; i++)
{
var name = names[i];
r.Name[i] = name;
r.Description[i] = "";
r.Value[i] = paramSet.GetValue(name);
r.Min[i] = paramSet.GetMinValue(name);
r.Max[i] = paramSet.GetMaxValue(name);
}
return r;
}
private void GetSmallestIntervalForValues( IHyperCube<double>[] points, string varName, out double minimum, out double maximum )
{
int n = points.Length;
double[] values = new double[n];
for( int j = 0; j < n; j++ )
values[j] = points[j].GetValue(varName);
minimum = MetaheuristicsHelper.GetMinimum( values );
maximum = MetaheuristicsHelper.GetMaximum( values );
}
