public void FindIncumbentGenomeReturnsGenomeFoundByCmaEs()
{
// Update with different instances to check we return the correct results later on.
this.Strategy.Initialize(this.CreatePopulation(), this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(
0,
new List <TestInstance> {
new TestInstance("a"), new TestInstance("b"), new TestInstance("c")
},
false);
this.Strategy.PerformIteration(
12,
new List <TestInstance> {
new TestInstance("c"), new TestInstance("d")
},
false);
this.Strategy.DumpStatus();
var incumbent = this.Strategy.FindIncumbentGenome();
Assert.Equal(12, incumbent.IncumbentGeneration);
Assert.Equal(
2,
incumbent.IncumbentInstanceResults.Count);
var status =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <TSearchPoint, TestInstance> >(this.StatusFilePath);
Assert.Equal(
status.MostRecentSorting.First().Genome.ToString(),
this.Strategy.FindIncumbentGenome().IncumbentGenome.ToString());
}
public override void DumpedStatusHasNoEmptyProperties()
{
var incumbent = this.CreateIncumbentGenomeWrapper();
this.Strategy.Initialize(this.CreatePopulation(), incumbent, this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.DumpStatus();
// Check last status dump
var lastStatus =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <TSearchPoint, TestInstance> >(this.StatusFilePath);
var sorting = lastStatus.MostRecentSorting;
for (int i = 0; i + 1 < sorting.Count; i++)
{
Assert.True(
Convert.ToInt32(sorting[i].Genome.CreateMutableGenome().GetGeneValue(ExtractIntegerValue.ParameterName).GetValue()) >
Convert.ToInt32(sorting[i + 1].Genome.CreateMutableGenome().GetGeneValue(ExtractIntegerValue.ParameterName).GetValue()),
"Points should be sorted.");
}
Assert.Equal(
this.SingleTestInstance.Select(instance => instance.ToString()).ToArray(),
lastStatus.CurrentEvaluationInstances.Select(instance => instance.ToString()).ToArray());
Assert.Equal(
incumbent.IncumbentGenome.ToString(),
lastStatus.OriginalIncumbent.ToString());
}
/// <summary> Move to. </summary>
/// <param name="device"> The device. </param>
/// <param name="position"> The position. </param>
/// <param name="deviceUnitConverter"> The device unit converter. </param>
public static bool MoveTo_1(IGenericAdvancedMotor device, decimal position, DeviceUnitConverter deviceUnitConverter)
{
// create wait handler
ManualResetEvent waitEvent = new ManualResetEvent(false);
int iPos = deviceUnitConverter.RealToDeviceUnit(position, DeviceUnitConverter.UnitType.Length);
Console.WriteLine("Moving Device to {0} ({1})", position, iPos);
// call moveto function, passing in event handler
// could alternatively use method with in-built wait handler by passing a timeout instead of callback
waitEvent.Reset();
// clear errors
device.ClearDeviceExceptions();
device.MoveTo_DeviceUnit(iPos, p =>
{
Console.WriteLine("Message Id {0}", p);
waitEvent.Set();
});
if (!waitEvent.WaitOne(60000))
{
return(false);
}
// check for exceptions thrown by background thread during process
device.ThrowLastDeviceException();
StatusBase status = device.Status;
Decimal newPos = status.Position;
Console.WriteLine("Device Moved to {0}({1})", newPos, position);
return(true);
}
public void InitializeKeepsCurrentMeans()
{
var population = this.CreatePopulation();
this.Strategy.Initialize(population, this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.DumpStatus();
var originalStatus =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <GenomeSearchPoint> >(this._deStatusFilePath);
var crossoverRate = originalStatus.MeanCrossoverRate;
var mutationFactor = originalStatus.MeanMutationFactor;
this.Strategy.Initialize(population, this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.DumpStatus();
var newlyInitializedStatus =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <GenomeSearchPoint> >(this._deStatusFilePath);
Assert.Equal(
crossoverRate,
newlyInitializedStatus.MeanCrossoverRate);
Assert.Equal(
mutationFactor,
newlyInitializedStatus.MeanMutationFactor);
}
/// <summary>
/// Finds the continuous optimization method's current generation, e.g. by reading the latest status file.
/// </summary>
/// <returns>
/// The current generation.
/// </returns>
protected override int FindCurrentGeneration()
{
var status =
StatusBase.ReadFromFile <CmaEsStatus>(this.CmaEsStatusFilePath);
return(status.Data.Generation);
}
public override void DumpedStatusHasNoEmptyProperties()
{
var incumbent = this.CreateIncumbentGenomeWrapper();
this.Strategy.Initialize(this.CreatePopulation(), incumbent, this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.DumpStatus();
// Check last status dump
var lastStatus =
StatusBase.ReadFromFile <DifferentialEvolutionStrategyStatus <TestInstance> >(this._statusFilePath);
var sorting = lastStatus.MostRecentSorting;
for (int i = 0; i + 1 < sorting.Count; i++)
{
Assert.True(sorting[i].Values[0] > sorting[i + 1].Values[0], "Points should be sorted.");
}
Assert.Equal(
this.SingleTestInstance.Select(instance => instance.ToString()).ToArray(),
lastStatus.CurrentEvaluationInstances.Select(instance => instance.ToString()).ToArray());
Assert.Equal(
incumbent.IncumbentGenome.ToString(),
lastStatus.OriginalIncumbent.ToString());
}
public void FindIncumbentGenomeReturnsBestInCurrentGeneration()
{
this.Strategy.Initialize(this.CreatePopulation(), this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(
0,
new List <TestInstance> {
new TestInstance("a"), new TestInstance("b"), new TestInstance("c")
},
false);
this.Strategy.PerformIteration(
12,
new List <TestInstance> {
new TestInstance("c"), new TestInstance("d")
},
false);
this.Strategy.DumpStatus();
var incumbent = this.Strategy.FindIncumbentGenome();
Assert.Equal(12, incumbent.IncumbentGeneration);
Assert.Equal(2, incumbent.IncumbentInstanceResults.Count);
var status =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <GenomeSearchPoint> >(this._deStatusFilePath);
var bestGenome = status.SortedPopulation
.OrderByDescending(point => point.Values[0])
.First().Genome.CreateMutableGenome();
Assert.True(
Genome.GenomeComparer.Equals(bestGenome, incumbent.IncumbentGenome),
$"Incumbent is {incumbent.IncumbentGenome} but should be {bestGenome}.");
}
/// <summary>
/// Finds the continuous optimization method's current generation, e.g. by reading the latest status file.
/// </summary>
/// <returns>
/// The current generation.
/// </returns>
protected override int FindCurrentGeneration()
{
var status =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <GenomeSearchPoint> >(this._deStatusFilePath);
return(status.CurrentGeneration);
}
public override void ReadFromFileDeserializesCorrectly()
{
var status = this.CreateTestStatus();
status.WriteToFile(this.StatusFilePath);
var deserializedStatus =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <SearchPoint> >(this.StatusFilePath);
/* Check it's still the same. */
Assert.Equal(
this._sortedPopulation.Select(point => point.Values).ToArray(),
deserializedStatus.SortedPopulation.Select(point => point.Values).ToArray());
Assert.Equal(
this._generation,
deserializedStatus.CurrentGeneration);
Assert.Equal(
this._maxGenerations,
status.MaxGenerations);
Assert.Equal(
this._meanCrossoverRate,
deserializedStatus.MeanCrossoverRate);
Assert.Equal(
this._meanMutationFactor,
deserializedStatus.MeanMutationFactor);
}
public void InitializeUsesCompleteCompetitivesIfNoIncumbentExistis()
{
var population = new Population(this.Configuration);
for (int i = 0; i < 5; i++)
{
population.AddGenome(this.GenomeBuilder.CreateRandomGenome(age: i % 3), isCompetitive: true);
}
for (int i = 0; i < 2; i++)
{
population.AddGenome(this.GenomeBuilder.CreateRandomGenome(age: i % 3), isCompetitive: false);
}
var competitivesAsSearchPoints = population.GetCompetitiveIndividuals()
.Select(individual => ContinuizedGenomeSearchPoint.CreateFromGenome(individual, this.ParameterTree));
this.Strategy.Initialize(population, null, this.SingleTestInstance);
this.Strategy.DumpStatus();
var status = StatusBase.ReadFromFile <CmaEsStatus>(this.CmaEsStatusFilePath);
var expectedDistributionMean = Vector <double> .Build.Dense(
Enumerable.Range(0, this.ParameterTree.GetParameters().Count())
.Select(i => competitivesAsSearchPoints.Average(point => point.Values[i]))
.ToArray());
Assert.Equal(
expectedDistributionMean,
status.Data.DistributionMean);
}
public void UseStatusDumpReinitializesBaseGenome()
{
var population = this.CreatePopulation();
this.Strategy.Initialize(population, this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance);
this.Strategy.PerformIteration(0, this.SingleTestInstance);
this.Strategy.DumpStatus();
var originalStatus =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <PartialGenomeSearchPoint, TestInstance> >(this.StatusFilePath);
var originalIncumbent = originalStatus.OriginalIncumbent;
var newStrategy = this.CreateStrategy(this.Configuration);
newStrategy.UseStatusDump(null);
var newStatus =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <PartialGenomeSearchPoint, TestInstance> >(this.StatusFilePath);
var expectedDiscreteValue = originalIncumbent.GetGeneValue("categorical").GetValue().ToString();
foreach (var point in newStatus.MostRecentSorting)
{
Assert.Equal(
expectedDiscreteValue,
point.Genome.CreateMutableGenome().GetGeneValue("categorical").GetValue().ToString());
}
}
public async Task SendStatus(StatusBase status, bool useQueue = true)
{
var t = status.GetType();
status.Name = t.Name;
status.DateTime = DateTime.UtcNow;
var ser = JsonConvert.SerializeObject(status);
var evt = new EventWrapper
{
Data = ser,
EventName = t.Name
};
var evtSer = JsonConvert.SerializeObject(evt);
if (!useQueue)
{
_storeStatus(evtSer);
}
else
{
await _mqttService.Send("events", evtSer);
}
}
/** ApplyStatus, protected virtual GameObject
* @Params : GameObject, Transform
* @Returns: GameObject
* This method should be called by spells that are able to apply a Status on their targets.
* The first param (GameObject status) should be a GameObject that has a StatusBase Script attached.
* Most of the time, this gameObject is contained in the SpellDefinition.Status Table, and the Transform is the target one.
* The method will instantiate a new Status and attach to it the status that is already attached on the first parameter.
* When we instantiate an object, the StatusBase element if reseted, so we need to attach this instance of the StatusBase because of previous modifications,
* such as damages or CDReduction of the Status of the player.
* Then, we return the fresh GameObject constructed if we want to use it later.
**/
protected virtual GameObject ApplyStatus(GameObject status, Transform tr)
{
GameObject objInst = Instantiate(status, tr);
StatusBase statusInst = objInst.GetComponent <StatusBase>();
statusInst.StartStatus(status.GetComponent <StatusBase>());
return(objInst);
}
public void ReadFromFileThrowsForWrongGenericType()
{
var status = this.CreateTestStatus();
status.WriteToFile(this.StatusFilePath);
Assert.Throws <InvalidCastException>(
() => StatusBase.ReadFromFile <WrongTypeStatus>(this.StatusFilePath));
}
public MonsterData(StatusBase s, GameObject m, int[] di, float[] dt, int exp, int mon)
{
status = s;
modle = m;
dropItem = di;
dropRate = dt;
experience = exp;
dropMoney = mon;
}
/// <summary>
/// Reads all internal data from file.
/// </summary>
/// <param name="pathToStatusFile">Path to the file to read.</param>
public void UseStatusDump(string pathToStatusFile)
{
var status = StatusBase.ReadFromFile <DifferentialEvolutionStatus <TSearchPoint> >(pathToStatusFile);
this._sortedPopulation = status.SortedPopulation?.Select(point => point.Restore()).ToList();
this._currentJadeGeneration = status.CurrentGeneration;
this._maxJadeGenerations = status.MaxGenerations;
this.MeanMutationFactor = status.MeanMutationFactor;
this.MeanCrossoverRate = status.MeanCrossoverRate;
}
// Use this for initialization
void Start()
{
allStatus = new List <StatusBase>();
allStatus.Add(new PlayerIdle(gameObject));
enemy = GameObject.Find("Enemy");
target = GameObject.Find("Target");
playerStatus = new PlayerIdle(gameObject);
playerStatus.OnStart();
}
public void RunnerUsesCorrectConfiguration()
{
this._runner.Initialize(this._configuration, this._terminationCriteria);
this._runner.DumpStatus(this._statusFilePath);
var status = StatusBase.ReadFromFile <CmaEsStatus>(this._statusFilePath);
Assert.Equal(
this._configuration.PopulationSize,
status.Data.Configuration.PopulationSize);
}
public void CallGenericSendRequest()
{
EmployeeFinance elf = new EmployeeFinance();
elf.Salary = 123434;
StatusBase status = ERPS.Utils.Functionals.Communicator.SendRequest <StatusBase, EmployeeFinance>(elf, "http://hellomelloyello.com", "POST", "application/octet-stream");
int i = 0;
++i;
}
protected void Awake()
{
_animator = GetComponent <Animator>();
var rigids = GetComponentsInChildren <Rigidbody2D>();
_rigidbody2D = GetComponent <Rigidbody2D>();
_sr = GetComponentInChildren <SpriteRenderer>();
status = new StatusBase();
_colliders = GetComponentsInChildren <CircleCollider2D>();
stepFoward = GetComponent <StepFoward>();
}
public CharacterData(StatusBase s, EquipData[] qd, GameObject[] go, Texture[] c, Texture nf, string str, int tot, GameObject[] ae, GrowthData gt)
{
status = s;
equips = qd;
modle = go;
charaImage = c;
nameFolder = nf;
personality = str;
totalExp = tot;
attackEffect = ae;
growthData = gt;
}
public static StatusBase operator -(StatusBase lhs, StatusBase rhs)
{
StatusBase result = new StatusBase(0, 0, 0, 0, 0, 0);
result.hp_ = lhs.hp_ - rhs.hp_;
result.a_ = lhs.a_ - rhs.a_;
result.b_ = lhs.b_ - rhs.b_;
result.c_ = lhs.c_ - rhs.c_;
result.d_ = lhs.d_ - rhs.d_;
result.s_ = lhs.s_ - rhs.s_;
return(result);
}
public void InitializeUsesIncumbentForDistributionMean()
{
var incumbent = this.CreateIncumbentGenomeWrapper();
this.Strategy.Initialize(this.CreatePopulation(), incumbent, this.SingleTestInstance);
this.Strategy.DumpStatus();
var status = StatusBase.ReadFromFile <CmaEsStatus>(this.CmaEsStatusFilePath);
Assert.Equal(
ContinuizedGenomeSearchPoint.CreateFromGenome(incumbent.IncumbentGenome, this.ParameterTree).Values,
status.Data.DistributionMean);
}
public static StatusBase operator *(StatusBase lhs, Entity_pokemon_personality.Param rhs)
{
StatusBase result = new StatusBase(0, 0, 0, 0, 0, 0);
result.hp_ = lhs.hp_;
result.a_ = (int)(lhs.a_ * rhs.A);
result.b_ = (int)(lhs.b_ * rhs.B);
result.c_ = (int)(lhs.c_ * rhs.C);
result.d_ = (int)(lhs.d_ * rhs.D);
result.s_ = (int)(lhs.s_ * rhs.S);
return(result);
}
public static StatusBase operator /(StatusBase lhs, int rhs)
{
StatusBase result = new StatusBase(0, 0, 0, 0, 0, 0);
result.hp_ = lhs.hp_ / rhs;
result.a_ = lhs.a_ / rhs;
result.b_ = lhs.b_ / rhs;
result.c_ = lhs.c_ / rhs;
result.d_ = lhs.d_ / rhs;
result.s_ = lhs.s_ / rhs;
return(result);
}
private void OnEnable()
{
_sr = GetComponent <SpriteRenderer>();
_collider2D = GetComponent <Collider2D>();
hitableState = HitableState.idle;
activeTake = false;
_sr.sprite = myHitableInfo.DefaultSprite;
tmpMat = _sr.material;
showEffect = false;
status = new StatusBase();
initData();
setBuffImmune();
}
/// <summary/>
internal InstallWindowModel(PrerequisiteBase[] prerequisites, Action <string, Action <string, double>, Action <string> > downloadFunc, IAdminProcessConnector adminProcessConnector)
{
Contract.Requires(prerequisites.All(_ => _.IsAlreadyInstalled == false));
this.prerequisites = prerequisites;
this.downloadFunc = downloadFunc;
this.adminProcessConnector = adminProcessConnector;
this.status = new PreperationStatus(
prerequisites.Select(_ => _.Name).ToArray(),
prerequisites.Any(_ => _.RequiresAdmin),
new DelegateCommand(this.SetUpSystem));
}
public void UseStatusDump(string pathToStatusFile)
{
if (this._currGeneration > 0)
{
throw new InvalidOperationException("Status dump should only be read in at the very beginning of tuning.");
}
// Read status from file.
var status = StatusBase.ReadFromFile <Status <TInstance, TResult, TModelLearner, TPredictorModel, TSamplingStrategy> >(pathToStatusFile);
// Check if old tuner parameters match the new ones.
if (this._configuration.StrictCompatibilityCheck && !this._configuration.IsCompatible(status.Configuration))
{
throw new InvalidOperationException(
$"Current configuration is too different from the one used to create status file {pathToStatusFile}.");
}
if (!this._configuration.IsTechnicallyCompatible(status.Configuration))
{
throw new InvalidOperationException(
$"It is technically not possible to continue the tuning of {pathToStatusFile} with the current configuration.");
}
if (status.ElapsedTime > TimeSpan.Zero)
{
this._logWriter.SetElapsedTimeOffset(status.ElapsedTime);
}
// Update fields.
this._currGeneration = status.Generation;
this._incumbentGenomeWrapper = status.IncumbentGenomeWrapper;
this.IncumbentQuality = status.IncumbentQuality;
this.GeneticEngineering = status.GeneticEngineering;
this.GeneticEngineering?.RestoreInternalDictionariesWithCorrectComparers();
this._informationHistory = status.InformationHistory;
// Send all run results to storage.
foreach (var genomeResults in status.RunResults)
{
foreach (var result in genomeResults.Value)
{
this._targetRunResultStorage.Tell(new ResultMessage <TInstance, TResult>(genomeResults.Key, result.Key, result.Value));
}
}
// Restore status of all population update strategies.
this._populationUpdateStrategyManager.UseStatusDump(status.CurrentUpdateStrategyIndex, status.Population, this.GeneticEngineering);
Randomizer.Reset();
Randomizer.Configure(new Random().Next());
}
/// <summary> Move to. </summary>
/// <param name="device"> The device. </param>
/// <param name="position"> The position. </param>
/// <param name="deviceUnitConverter"> The device unit converter. </param>
public static bool MoveTo_3(IGenericAdvancedMotor device, decimal position, DeviceUnitConverter deviceUnitConverter)
{
int iPos = deviceUnitConverter.RealToDeviceUnit(position, DeviceUnitConverter.UnitType.Length);
Console.WriteLine("Moving Device to {0} ({1})", position, iPos);
device.MoveTo_DeviceUnit(iPos, 60000);
StatusBase status = device.Status;
Decimal newPos = status.Position;
Console.WriteLine("Device Moved to {0}({1})", newPos, position);
return(true);
}
public void UseStatusDumpWorksCorrectly()
{
// Create a status dump.
this._runner.Initialize(this._configuration, this._terminationCriteria);
this._runner.NextGeneration();
this._runner.DumpStatus(this._statusFilePath);
var originalStatusDump = StatusBase.ReadFromFile <CmaEsStatus>(this._statusFilePath);
// Create a different runner, then use status dump.
var otherConfiguration = new CmaEsConfiguration(14, Vector <double> .Build.Dense(3), 0.2);
var otherTerminationCriteria = new List <ITerminationCriterion> {
new MaxIterations(89)
};
this._runner.Initialize(otherConfiguration, otherTerminationCriteria);
this._runner.UseStatusDump(this._statusFilePath);
// Check newly dumped status vs old one.
this._runner.DumpStatus(this._statusFilePath);
var newStatusDump = StatusBase.ReadFromFile <CmaEsStatus>(this._statusFilePath);
// Compare dumps
TestUtils.SetsAreEquivalent(
originalStatusDump.TerminationCriteria.Select(criterion => criterion.GetType()).ToArray(),
newStatusDump.TerminationCriteria.Select(criterion => criterion.GetType()).ToArray());
Assert.Equal(
originalStatusDump.Data.Configuration.CumulationLearningRate,
newStatusDump.Data.Configuration.CumulationLearningRate);
Assert.Equal(originalStatusDump.Data.Generation, newStatusDump.Data.Generation);
Assert.Equal(
originalStatusDump.Data.DistributionMean,
newStatusDump.Data.DistributionMean);
Assert.Equal(originalStatusDump.Data.StepSize, newStatusDump.Data.StepSize);
Assert.Equal(
originalStatusDump.Data.Covariances,
newStatusDump.Data.Covariances);
Assert.Equal(originalStatusDump.Data.CovariancesDiagonal, newStatusDump.Data.CovariancesDiagonal);
Assert.Equal(
originalStatusDump.Data.CovariancesEigenVectors,
newStatusDump.Data.CovariancesEigenVectors);
Assert.Equal(
originalStatusDump.Data.EvolutionPath,
newStatusDump.Data.EvolutionPath);
Assert.Equal(
originalStatusDump.Data.ConjugateEvolutionPath,
newStatusDump.Data.ConjugateEvolutionPath);
}
