public void ConfigureChannelDutyCycle(uint channel, double dutyCycle) { if (dutyCycle >= 1.0) { SetFullOn(channel); return; } if (dutyCycle <= 0.0) { SetFullOff(channel); return; } uint onCount = 0; var offCount = (uint)Math.Floor(PwmCounterCycle * dutyCycle); if (offCount <= onCount) { offCount = onCount + 1; // The two counts may not be the same value } var registerOffset = (byte)(Pca9685.Channel0OnLow + (4 * channel)); WriteConsecutiveRegisters( registerOffset, (byte)onCount, (byte)(onCount >> 8), (byte)offCount, (byte)(offCount >> 8)); }
private static void AlignToGrid(ref Vector2 point) { Vector2 floorPoint = new Vector2((float)MathF.Floor(point.X), (float)MathF.Floor(point.Y)); Vector2 decimalPart = point - floorPoint; if (decimalPart.X < 0.5) { decimalPart.X = 0; } else { decimalPart.X = 1; } if (decimalPart.Y < 0.5) { decimalPart.Y = 0; } else { decimalPart.Y = 1f; } point = floorPoint + decimalPart; }
public IEnumerable <double> GetVisibleXPoints() { for (var x = M.Ceiling(MinimalVisibleX); x <= M.Floor(MaximalVisibleX); x++) { yield return(x); } }
//Reduction public static string Reduction_0(double costs) { string ret = "Over"; if (notation == 0) { if (costs < 1000) { ret = costs.ToString("N0"); } else { if (costs < 999999) { ret = Math.Floor(costs).ToString(); } else { //ret = costs.ToString("g3"); 1.000e6 = 1 000 000 double prov = 1000000; int prov_n = 0; for (int i = 0; costs > prov; i++) { prov *= 10; prov_n = i; } ret = (Math.Floor(costs / (prov / 10000d)) / 1000d) + "e" + (prov_n + 6); } } } return(ret); }
public double GetSmoothedNoise(Vec3 p_point) { var u = p_point.X - Math.Floor(p_point.X); var v = p_point.Y - Math.Floor(p_point.Y); var w = p_point.Z - Math.Floor(p_point.Z); var i = (int)Math.Floor(p_point.X); var j = (int)Math.Floor(p_point.Y); var k = (int)Math.Floor(p_point.Z); var c = new Vec3[2, 2, 2]; for (var di = 0; di < 2; ++di) { for (var dj = 0; dj < 2; ++dj) { for (var dk = 0; dk < 2; ++dk) { c[di, dj, dk] = RandomVector [PermutateX[(i + di) & 255] ^ PermutateY[(j + dj) & 255] ^ PermutateZ[(k + dk) & 255]]; } } } return(PerlinInterpolate(c, u, v, w)); }
public IEnumerable <double> GetVisibleYPoints() { for (var y = M.Ceiling(MinimalVisibleY); y <= M.Floor(MaximalVisibleY); y++) { yield return(y); } }
public static float LinearInterpolate(Vector2 position, MapData[,] map, ScalarFieldType fieldType) { float x = position.X; float y = position.Y; float x1 = (int)MathFunctions.Clamp((float)Math.Ceiling(x), 0, map.GetLength(0) - 2); float y1 = (int)MathFunctions.Clamp((float)Math.Ceiling(y), 0, map.GetLength(1) - 2); float x2 = (int)MathFunctions.Clamp((float)Math.Floor(x), 0, map.GetLength(0) - 2); float y2 = (int)MathFunctions.Clamp((float)Math.Floor(y), 0, map.GetLength(1) - 2); if (Math.Abs(x1 - x2) < 0.5f) { x1 = x1 + 1; } if (Math.Abs(y1 - y2) < 0.5f) { y1 = y1 + 1; } float q11 = map[(int)x1, (int)y1].GetValue(fieldType); float q12 = map[(int)x1, (int)y2].GetValue(fieldType); float q21 = map[(int)x2, (int)y1].GetValue(fieldType); float q22 = map[(int)x2, (int)y2].GetValue(fieldType); return(MathFunctions.LinearCombination(x, y, x1, y1, x2, y2, q11, q12, q21, q22)); }
public Point GetClosestPointOnTile(Point position, out bool success) { lock (_threadLocker) { float[] extents = new Point(20.0f, 2000.0f, 20.0f).ToFloatArray(); float[] center = position.ToRecast().ToFloatArray(); float tx, ty; GetTileByLocation(position, out tx, out ty); int x = (int)Math.Floor(tx); int y = (int)Math.Floor(ty); LoadTile(x, y); dtPolyRef startRef = _query.FindNearestPolygon(center, extents, Filter); if (startRef == 0) { success = false; return(new Point()); } float[] result; DetourStatus status = _query.closestPointOnPolyBoundary(startRef, center, out result); if (status.HasFailed()) { success = false; return(new Point()); } success = true; return(new Point(result.ToWoW())); } }
public void CachesTheApiResultsInMemorySoTheApiIsNotCalledTwiceForTheSameProjects( NonEmptyArray <NonNegativeInt> projectIds) { var actualProjectIds = projectIds.Get.Select(i => (long)i.Get).Distinct().ToArray(); var idCount = actualProjectIds.Length; if (idCount < 2) { return; } var dbProjectCount = (int)Math.Floor((float)idCount / 2); var apiProjectCount = idCount - dbProjectCount; var projectsInDb = actualProjectIds.Take(dbProjectCount).ToArray(); var projectsInApi = actualProjectIds.TakeLast(apiProjectCount).ToArray(); var summaries = getSummaryList(actualProjectIds); apiProjectsSummary.ProjectsSummaries.Returns(summaries); configureRepositoryToReturn(projectsInDb, projectsInApi); configureApiToReturn(projectsInApi); GetInteractor(workspaceId, DateTimeOffset.Now.AddDays(-7), DateTimeOffset.Now).Execute().Wait(); GetInteractor(workspaceId, DateTimeOffset.Now.AddDays(-7), DateTimeOffset.Now).Execute().Wait(); ProjectsApi.Received(1) .Search(workspaceId, Arg.Is <long[]>( calledIds => ensureExpectedIdsAreReturned(calledIds, projectsInApi))); }
public float GetZ(Point position, bool strict = false) { lock (_threadLocker) { float[] extents = strict ? new Point(0.5f, 2000.0f, 0.5f).ToFloatArray() : new Point(1.5f, 2000.0f, 1.5f).ToFloatArray(); float[] center = position.ToRecast().ToFloatArray(); float tx, ty; GetTileByLocation(position, out tx, out ty); int x = (int)Math.Floor(tx); int y = (int)Math.Floor(ty); LoadTile(x, y); dtPolyRef startRef = _query.FindNearestPolygon(center, extents, Filter); if (startRef == 0) { Logging.WriteDebug("There is no polygon in this location (Tile " + x + "," + y + "), coord: X:" + position.X + ", Y:" + position.Y); return(0); } float z = _query.GetPolyHeight(startRef, center); if (z == 0 && !strict) // it failed but we are not strict, then search around { float[] result; DetourStatus status = _query.closestPointOnPolyBoundary(startRef, center, out result); z = status.HasFailed() ? 0 : result[1]; } return(z); } }
/// <summary> /// Initializes a new instance of the <see cref="ImageBrushApplicator"/> class. /// </summary> /// <param name="target">The target image.</param> /// <param name="image">The image.</param> /// <param name="region">The region.</param> /// <param name="options">The options</param> public ImageBrushApplicator(ImageFrame <TPixel> target, ImageFrame <TPixel> image, RectangleF region, GraphicsOptions options) : base(target, options) { this.source = image; this.xLength = image.Width; this.yLength = image.Height; this.offsetY = (int)MathF.Max(MathF.Floor(region.Top), 0); this.offsetX = (int)MathF.Max(MathF.Floor(region.Left), 0); }
/// <summary> /// Reduces a given angle to a value between π and -π. /// </summary> /// <param name="radians"></param> /// <returns></returns> public static double WrapAngle(double radians) { int revolutions = (int)NMath.Floor(radians / Numbers.TwoPi); double wrappedAngle = radians - revolutions * Numbers.TwoPi; if (NMath.Abs(wrappedAngle) > Numbers.Pi) { return(-NMath.Sign(wrappedAngle) * (Numbers.TwoPi - NMath.Abs(wrappedAngle))); } return(wrappedAngle); }
/// <summary> /// Tworzy tekst statyczny ale string zostanie automatycznie podzielony na nowe linie tak aby pasowal do okienka w ktorym ma byc wyswietlony /// </summary> /// <param name="D"></param> /// <param name="T"></param> /// <returns></returns> public OverlayContainer createStaticTextAutoSplit(Vector4 D, String T) { uint h = this.mGUI.mFontSize; // margin and font size Font font = (Font)(Mogre.FontManager.Singleton.GetByName(this.mGUI.mFont).Target); Vector2 averageSize = ViewHelper.GetTextAverageSize(T, font, h); int charsPerLine = (int)Math.Floor((D.z - 2 * h) / averageSize.x); string multiline = LanguageResources.SplitInsertingNewLinesByLength(T, charsPerLine); return(createStaticText(D, multiline, ColourValue.White)); }
public double GetNoise(Vec3 p_point) { var u = p_point.X - Math.Floor(p_point.X); var v = p_point.Y - Math.Floor(p_point.Y); var w = p_point.Z - Math.Floor(p_point.Z); var i = (int)(4 * p_point.X) & 255; var j = (int)(4 * p_point.Y) & 255; var k = (int)(4 * p_point.Z) & 255; return(RandomDouble[PermutateX[i] ^ PermutateY[j] ^ PermutateZ[k]]); }
public void Estimate1D(decimal min, decimal max, decimal step) { var param = new OptimizationStepParameter("ema-fast", min, max, step); var set = new HashSet <OptimizationParameter>() { param }; _strategy.Initialize(new Target("Profit", new Maximization(), null), new List <Constraint>(), set, new StepBaseOptimizationStrategySettings()); Assert.AreEqual(Math.Floor(Math.Abs(max - min) / Math.Abs(step)) + 1, _strategy.GetTotalBacktestEstimate()); }
public static void OnNPCRecruited(NPCBase npc) { if (npc.GetTempValues().TryGet(ISSETTLER, out bool settler) && settler) { return; } var ps = PlayerState.GetPlayerState(npc.Colony.Owner); if (ps.SettlersEnabled) { if (Configuration.GetorDefault("ColonistsRecruitment", true)) { if (ps.SettlersEnabled && npc.Colony.FollowerCount > MAX_BUYABLE) { var cost = Configuration.GetorDefault("CompoundingFoodRecruitmentCost", 5) * ps.ColonistsBought; var num = 0f; if (cost < 1) { cost = 1; } if (npc.Colony.UsedStockpile.TotalFood < cost || !npc.Colony.UsedStockpile.TryRemoveFood(ref num, cost)) { Chat.Send(npc.Colony.Owner, $"<color=red>Could not recruit a new colonist; not enough food in stockpile. {cost + ServerManager.ServerVariables.LaborerCost} food required.</color>", ChatSenderType.Server); npc.Colony.UsedStockpile.Add(BuiltinBlocks.Bread, (int)Math.Floor(ServerManager.ServerVariables.LaborerCost / 3)); npc.health = 0; npc.Update(); return; } ps.ColonistsBought++; ps.NextColonistBuyTime = TimeCycle.TotalTime + 24; } SettlerInventory.GetSettlerInventory(npc); UpdateFoodUse(npc.Colony.Owner); } else { PandaChat.Send(npc.Colony.Owner, "The server administrator has disabled recruitment of colonists while settlers are enabled."); } } }
public static int IntLength(int i) { if (i < 0) { throw new ArgumentOutOfRangeException(); } if (i == 0) { return(1); } return((int)MathL.Floor(MathL.Log10(i)) + 1); }
//damage on enemy public void damage_enemy() { double profit = game_manager.army_dmg[nomber]; game_manager.enemy_hp -= profit; if (profit > game_manager.enemy_mhp) { profit = game_manager.enemy_mhp; } profit = 1d / game_manager.enemy_mhp * profit; game_manager.player_coin += Math.Floor(game_manager.enemy_coin * profit); }
/// <summary> /// /// </summary> /// <param name="value"></param> /// <param name="min"></param> /// <param name="max"></param> /// <returns></returns> public static float Wrap(float value, float min, float max) { if (NearEqual(min, max)) { return(min); } double mind = min; double maxd = max; double valued = value; double range_size = maxd - mind; return((float)(mind + (valued - mind) - (range_size * SysMath.Floor((valued - mind) / range_size)))); }
// -------------------------------------------------------------------------------------------------------------------------- /// <summary> /// Returns a random string of the given length that only contains numbers. /// </summary> public static string GetNumberString(int size) { StringBuilder builder = new StringBuilder(); lock (RndLock) { char ch; for (int i = 0; i < size; i++) { ch = Convert.ToChar(Convert.ToInt32(SysMath.Floor(10 * RNG.NextDouble() + 48))); builder.Append(ch); } } return(builder.ToString()); }
/// <summary> /// Reduces a given angle to a value between 0 and 2π radians, matching the sign of the angle. /// </summary> /// <param name="radians">The angle in radians.</param> /// <param name="tolerance">The tolerance.</param> /// <returns>System.Double.</returns> public static double WrapAngleWithinTwoPi(double radians, double tolerance = Numbers.ZeroTolerance) { if (radians.IsZeroSign(tolerance)) { radians = 0; } if (radians == double.PositiveInfinity || radians == double.NegativeInfinity) { return(double.PositiveInfinity); } int inferredRounding = NMath.Max(Numbers.DecimalPlaces(radians), 6); double roundedPi = NMath.Round(Numbers.TwoPi, inferredRounding); int revolutions = (int)NMath.Round(NMath.Floor(radians / roundedPi), inferredRounding); return(radians - revolutions * roundedPi); }
public void AddSeconds(double sec) { week.Seconds += sec; if (sec < 0) { int weekNum = (int)Math.Ceiling(sec / Time.SecondsPerWeek); week.Weeks -= weekNum; Week.Seconds += weekNum * Time.SecondsPerWeek; Week = Week; } else { int weekNum = (int)Math.Floor(sec / Time.SecondsPerWeek); week.Weeks += weekNum; Week.Seconds -= weekNum * Time.SecondsPerWeek; Week = Week; } }
public static Point3d Evaluate3D(IList <Point3d> points, bool cerrada, double t) { if (cerrada) { t = t % points.Count; int i = (int)Math.Floor(t); int inext = (i + 1) % points.Count; double alfa = t - i; return(points[i].Lerp(points[inext], alfa)); } else { int i = (int)Math.Floor(t); int inext = i + 1; double alfa = t - i; return(points[i].Lerp(points[inext], alfa)); } }
public static int GetDecimalPlaces(double value) { // increasing max decimal places above 10 produces weirdness int maxDecimalPlaces = 10; double threshold = MathL.Pow(0.1d, maxDecimalPlaces); if (value == 0.0) { return(0); } int decimalPlaces = 0; while (value - MathL.Floor(value) > threshold && decimalPlaces < maxDecimalPlaces) { value *= 10.0; decimalPlaces++; } return(decimalPlaces); }
public void Step1D(decimal min, decimal max, decimal step) { var param = new OptimizationStepParameter("ema-fast", min, max, step); var set = new HashSet <OptimizationParameter>() { param }; _strategy.Initialize(new Target("Profit", new Maximization(), null), new List <Constraint>(), set, new StepBaseOptimizationStrategySettings()); var counter = 0; using (var enumerator = new EnqueueableEnumerator <ParameterSet>()) { _strategy.NewParameterSet += (s, parameterSet) => { enumerator.Enqueue(parameterSet); }; _strategy.PushNewResults(OptimizationResult.Initial); using (var paramEnumerator = new OptimizationStepParameterEnumerator(param)) { while (paramEnumerator.MoveNext()) { var value = paramEnumerator.Current; counter++; Assert.IsTrue(enumerator.MoveNext()); var suggestion = enumerator.Current; Assert.IsNotNull(suggestion); Assert.IsTrue(suggestion.Value.All(s => set.Any(arg => arg.Name == s.Key))); Assert.AreEqual(1, suggestion.Value.Count); Assert.AreEqual(value, suggestion.Value["ema-fast"]); } } Assert.AreEqual(0, enumerator.Count); } Assert.Greater(counter, 0); Assert.AreEqual(Math.Floor((param.MaxValue - param.MinValue) / param.Step.Value) + 1, counter); }
public void Estimate2D(decimal[,] data) { var args = new HashSet <OptimizationParameter>() { new OptimizationStepParameter("ema-fast", data[0, 0], data[0, 1], data[0, 2]), new OptimizationStepParameter("ema-slow", data[1, 0], data[1, 1], data[1, 2]) }; _strategy.Initialize(new Target("Profit", new Maximization(), null), new List <Constraint>(), args, new StepBaseOptimizationStrategySettings()); var total = 1m; foreach (var arg in args.Cast <OptimizationStepParameter>()) { total *= Math.Floor((arg.MaxValue - arg.MinValue) / arg.Step.Value) + 1; } Assert.AreEqual(total, _strategy.GetTotalBacktestEstimate()); }
/// <summary> /// Rounds to significant figures. /// </summary> /// <seealso cref="RoundToSignificantFigures">https://en.wikipedia.org/wiki/Significant_figures</seealso> /// <param name="value">The value.</param> /// <param name="significantFigures">The number of significant figures.</param> /// <param name="roundingTieBreaker">Method by which rounding is performed if the triggering rounding number is 5.</param> /// <returns>System.Double.</returns> public static double RoundToSignificantFigures( double value, int significantFigures, RoundingTieBreaker roundingTieBreaker = RoundingTieBreaker.HalfAwayFromZero) { if (value == 0 || significantFigures == 0) { return(0); } // Get value scaled to having sig figs result as an integer e.g. 4th sig fig 12345 = 1234.5 or 0.00012345 = 1234.5, 7th sig fig 12.345 = 1234500 double scale = NMath.Pow(10, NMath.Floor(NMath.Log10(NMath.Abs(value))) + 1 - significantFigures); double valueScale = value / scale; // Round in case floating point affects number outside of precision (e.g. for 0.545 vs. 0.5449999999 for rounding to 0.6) double valueScaleRounded = NMath.Round(valueScale, 2); // scale back up return(scale * NMath.Round(valueScaleRounded, midpointRounding(roundingTieBreaker))); }
/// <summary> /// Creates the windows of the facade /// </summary> /// <param name="vertices">The array containing the mesh's vertices, ref type</param> /// <returns></returns> private List <Face> CreateWindows(ref Vector3[] vertices) { //Remaining space should be the same on both ends int horizontalWindows = (int)Math.Floor(width / (windowWidth + windowWidthSpacing * 2)); var relativeLeftStartPos = (width - horizontalWindows * (windowWidth + windowWidthSpacing * 2)) / 2; var createdFaces = new List <Face>(); //Get the height parts of all the lower-left coordinates, goes from the height of the door section to the top for (float heightLowerStart = doorSectionHeight; heightLowerStart + windowHeight + windowHeightSpacing < height; heightLowerStart += windowHeight + windowHeightSpacing * 2) { //Get the width parts of all the lower-left coordinates, goes from left edge + spacing to the other edge for (float widthLeftStart = genCoords.x + windowWidthSpacing + relativeLeftStartPos; widthLeftStart + windowWidth < width; widthLeftStart += windowWidth + windowWidthSpacing * 2) { createdFaces.Add(CreateWindowAt(ref vertices, new Vector3(widthLeftStart, heightLowerStart, genCoords.z))); } } return(createdFaces); }
public void AddMinesToTheBoard() { var min = (int)Math.Ceiling(Width * Height * 0.2); var max = (int)Math.Floor(Width * Height * 0.6); var mineCount = random.Next(min, max); RemainingMineCount = mineCount; while (mineCount > 0) { var row = random.Next(0, Width - 1); var column = random.Next(0, Height - 1); if (Board[row, column].State == State.Mine) { continue; } Board[row, column].State = State.Mine; mineCount--; for (var i = 0; i < 8; i++) { int xDir = Helper.Directions[i, 0]; int yDir = Helper.Directions[i, 1]; if (Helper.CellIsOutOfTheBoardRange(xDir, yDir, row, column, Width, Height)) { continue; } if (Board[row + yDir, column + xDir].State == State.MinesAround || Board[row + yDir, column + xDir].State == State.Empty) { Board[row + yDir, column + xDir].State = State.MinesAround; Board[row + yDir, column + xDir].MinesAround++; } } } }
internal Rectangle GetImageRectangle(float dpi) { var rect = Rectangle.ToRectangleF(); var mul = dpi / 72f; var values = new[] { rect.X *mul, rect.Y *mul, rect.Width *mul, rect.Height *mul }; // BUG 0015690 for (int i = 0; i < values.Length; i++) { var v = SMath.Round(values[i]); if (SMath.Abs(v - values[i]) < 0.01f) { values[i] = (float)v; } } int x = (int)SMath.Floor(values[0]); int y = (int)SMath.Floor(values[1]); int width = (int)SMath.Ceiling(values[2]); int height = (int)SMath.Ceiling(values[3]); return(new Rectangle(x, y, width, height)); }