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); }