/// <summary> /// Constructs a <see cref="Xenon.Math.BoundingSphere"/> that is the as large as the total combined area of the two specified spheres. /// </summary> /// <param name="value1">The first sphere to merge.</param> /// <param name="value2">The second sphere to merge.</param> /// <param name="result">When the method completes, contains the newly constructed bounding sphere.</param> public static void Merge(ref BoundingSphere value1, ref BoundingSphere value2, out BoundingSphere result) { Vector3 difference = value2.Center - value1.Center; float length = difference.Length; float radius = value1.Radius; float radius2 = value2.Radius; if (radius + radius2 >= length) { if (radius - radius2 >= length) { result = value1; return; } if (radius2 - radius >= length) { result = value2; return; } } Vector3 vector = difference * (1.0f / length); float min = SMath.Min(-radius, length - radius2); float max = (SMath.Max(radius, length + radius2) - min) * 0.5f; result.Center = value1.Center + vector * (max + min); result.Radius = max; }
public static void SetWater(MapData[,] heightMap, Vector2 pos, WaterType waterType) { int x = Math.Max(Math.Min((int)pos.X, heightMap.GetLength(0) - 1), 0); int y = Math.Max(Math.Min((int)pos.Y, heightMap.GetLength(1) - 1), 0); heightMap[x, y].Water = waterType; }
/// <summary> /// Implements the - operator. /// </summary> /// <param name="point1">The point1.</param> /// <param name="point2">The point2.</param> /// <returns>The result of the operator.</returns> public static Offset3D operator -(Point3D point1, Point3D point2) { return(new Offset3D( point1, point2, NMath.Min(point1.Tolerance, point2.Tolerance))); }
public static float GetHeight(float[,] heightMap, Vector2 pos) { int x = Math.Max(Math.Min((int)pos.X, heightMap.GetLength(0) - 1), 0); int y = Math.Max(Math.Min((int)pos.Y, heightMap.GetLength(1) - 1), 0); return(heightMap[x, y]); }
public static WaterType GetWater(MapData[,] map, Vector2 pos) { int x = Math.Max(Math.Min((int)pos.X, map.GetLength(0) - 1), 0); int y = Math.Max(Math.Min((int)pos.Y, map.GetLength(1) - 1), 0); return(map[x, y].Water); }
public static byte[] Render(Scene scene, byte[] pixels) { var eye = Vec3.Zero; Num h = MATH.Tan(((fov / 360) * (2 * PI)) / 2) * 2; Num w = (h * Width) / Height; for (int y = 0; y != Height; ++y) { for (int x = 0; x != Width; ++x) { Num xx = x, yy = y, ww = Width, hh = Height; Vec3 dir; dir.X = ((xx - (ww / 2.0f)) / ww) * w; dir.Y = (((hh / 2.0f) - yy) / hh) * h; dir.Z = -1.0f; dir = Vec3.Normalize(dir); Ray r; r.Org = eye; r.Dir = dir; var pixel = trace(r, scene, 0); int i = (x * 3) + (y * Width * 3); pixels[i] = (byte)MATH.Min(pixel.X * 255, 255); pixels[i + 1] = (byte)MATH.Min(pixel.Y * 255, 255); pixels[i + 2] = (byte)MATH.Min(pixel.Z * 255, 255); } } return(pixels); }
/// <summary> /// Implements the + operator. /// </summary> /// <param name="point1">The point1.</param> /// <param name="point2">The point2.</param> /// <returns>The result of the operator.</returns> public static Point operator +(Offset point1, Point point2) { return(new Point( point1.X() + point2.X, point1.Y() + point2.Y, NMath.Min(point1.Tolerance, point2.Tolerance))); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns>true if the current object is equal to the <paramref name="other" /> parameter; otherwise, false.</returns> public bool Equals(PolarOffset other) { double tolerance = NMath.Min(Tolerance, other.Tolerance); return(Radius().IsEqualTo(other.Radius(), tolerance) && Azimuth().Radians.IsEqualTo(other.Azimuth().Radians, tolerance)); }
private IEnumerable <Task> ScheduleJobs(float deltaTime, Task inputDeps) { ReadOnlyMemory <PositionComponent> allPositions = this.positionComponents; //Velocity to be modified ReadOnlyMemory <PositionComponent> positions = allPositions.Slice(0, this.length); ReadOnlyMemory <VelocityConstraintComponent> velocityConstraints = this.constraintComponents.Slice(0, this.length); Memory <VelocityComponent> velocities = this.velocityComponents.Slice(0, this.length); //Velocity modifier data ReadOnlyMemory <VelocityModifierComponent> modifiers = this.modifierComponents; ReadOnlyMemory <PositionComponent> modifierPositions = allPositions.Slice(this.length); ReadOnlyMemory <SizeComponent> modifierSizes = this.sizeComponents; for (int i = 0; i < Environment.ProcessorCount; i++) { var startIndex = i * this.sliceLength; var sliceLength = Math.Min(this.sliceLength, this.length - startIndex); var positionsSlice = positions.Slice(startIndex, sliceLength); var velocityConstraintsSlice = velocityConstraints.Slice(startIndex, sliceLength); var velocitiesSlice = velocities.Slice(startIndex, sliceLength); yield return(inputDeps.ContinueWith((x) => RunJob( deltaTime, sliceLength, this.modifierLength, positionsSlice, velocityConstraintsSlice, velocitiesSlice, modifiers, modifierPositions, modifierSizes))); } }
public static Bitmap ResizeBitmapFromUri(this Uri uri, int newWidth, int newHeight) { try { var bmOptions = new BitmapFactory.Options { InJustDecodeBounds = true }; BitmapFactory.DecodeFile(uri.EncodedPath, bmOptions); var photoW = bmOptions.OutWidth; var photoH = bmOptions.OutHeight; var scaleFactor = 1; if ((newWidth > 0) || (newHeight > 0)) { scaleFactor = Math.Min(photoW / newWidth, photoH / newHeight); } bmOptions.InJustDecodeBounds = false; bmOptions.InSampleSize = scaleFactor; bmOptions.InPurgeable = true; return(BitmapFactory.DecodeFile(uri.EncodedPath, bmOptions)); } catch (Exception ex) { return(null); } }
private static void Transfer(Socket socket) { int txDataLen = random.Next(maxDataLen); int rxDataLen; TransferHeaders(socket, txDataLen, out rxDataLen); // System.Console.WriteLine ("txDataLen="+txDataLen+" rxDataLen="+rxDataLen); socket.Blocking = false; socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1); // Disable the Nagle algorithm for send coalescing. int txPos = 0; int rxPos = 0; while (txPos < txDataLen || rxPos < rxDataLen) { // System.Console.WriteLine ("txPos="+txPos+"/"+txDataLen+" rxPos="+rxPos+"/"+rxDataLen); int txReqLen = Math.Min(txDataLen - txPos, 1 + random.Next(maxBlockLen)); int txTrLen = Send(socket, txReqLen); txPos += txTrLen; int rxReqLen = Math.Min(rxDataLen - rxPos, maxBlockLen); int rxTrLen = Receive(socket, rxReqLen); rxPos += rxTrLen; if (random.Next(1000) == 0) { Thread.Sleep(50); } else if ((txTrLen < txReqLen && rxTrLen < rxReqLen) || random.Next(50) == 0) { Thread.Sleep(1); } } socket.Shutdown(SocketShutdown.Both); }
// Takes Hue value as input, returns RGB vector. // Copied from POV-Ray public static Vector3D CH2RGB(double H) { double R = 0, G = 0, B = 0; if (H >= 0 && H < 120) { R = (120 - H) / 60; G = (H - 0) / 60; B = 0; } else if (H >= 120 && H < 240) { R = 0; G = (240 - H) / 60; B = (H - 120) / 60; } else if (H >= 240 && H <= 360) { R = (H - 240) / 60; G = 0; B = (360 - H) / 60; } return(new Vector3D( Math.Min(R, 1), Math.Min(G, 1), Math.Min(B, 1))); }
static public SkryptObject Min(SkryptObject[] Values) { var a = TypeConverter.ToNumeric(Values, 0); var b = TypeConverter.ToNumeric(Values, 1); return((Numeric)SysMath.Min(a, b)); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns>true if the current object is equal to the <paramref name="other" /> parameter; otherwise, false.</returns> public bool Equals(CartesianCoordinate other) { double tolerance = NMath.Min(Tolerance, other.Tolerance); return(X.IsEqualTo(other.X, tolerance) && Y.IsEqualTo(other.Y, tolerance)); }
/// <summary> /// Requests the resource from all parts in the collection /// </summary> /// <param name="parts">All of the donor parts</param> /// <param name="transferGoal">the aggregate amount we are seeking to remove from parts</param> /// <returns>the amount we were successful at pulling</returns> private double PullResources(IList <global::Part> parts, double transferGoal, double deltaTime) { double toReturn = 0.0; var availableResources = CalculateAvailableResource(parts); foreach (var part in parts) { var resource = part.Resources.Get(resourceInfo.id); if (resource == null) { continue; } var thisPartsPercentage = resource.amount / availableResources; // Throttle the transfer var thisPartsShare = transferGoal * thisPartsPercentage; var thisPartsRate = resource.maxAmount * RESOURCE_SHARE_PER_UPDATE * deltaTime / 0.02; // The amount you pull must be negative thisPartsShare = -Math.Min(thisPartsShare, thisPartsRate); // the amount is subject to floating point lameness, if we round it here it is not material to the request but should make the numbers work out nicer. thisPartsShare = Math.Round(thisPartsShare, 5); toReturn += part.TransferResource(resourceInfo.id, thisPartsShare); } return(toReturn); }
public void SetPosition2(IntFloatVector2 pos) { var x = pos.X.Integer * 2 + 1; var y = pos.Y.Integer * 2 + 1; var oldX = Position.X.Integer * 2 + 1; var oldY = Position.Y.Integer * 2 + 1; Position = pos; // for slice updates we are only interested in the integer part if (x == oldX && y == oldY) { return; } if (y > oldY) { UpdateRows((_n - oldY) & _n, Math.Min((y - oldY), _n)); } else if (oldY > y) { UpdateRows((_n - y) & _n, Math.Min((oldY - y), _n)); } if (x > oldX) { UpdateColumns((_n - oldX) & _n, Math.Min((x - oldX), _n)); } else if (oldX > x) { UpdateColumns((_n - x) & _n, Math.Min((oldX - x), _n)); } }
private float IntersectionOverUnion(Rect boundingBoxA, Rect boundingBoxB) { var areaA = boundingBoxA.width * boundingBoxA.height; if (areaA <= 0) { return(0); } var areaB = boundingBoxB.width * boundingBoxB.height; if (areaB <= 0) { return(0); } var minX = Math.Max(boundingBoxA.xMin, boundingBoxB.xMin); var minY = Math.Max(boundingBoxA.yMin, boundingBoxB.yMin); var maxX = Math.Min(boundingBoxA.xMax, boundingBoxB.xMax); var maxY = Math.Min(boundingBoxA.yMax, boundingBoxB.yMax); var intersectionArea = Math.Max(maxY - minY, 0) * Math.Max(maxX - minX, 0); return(intersectionArea / (areaA + areaB - intersectionArea)); }
public Move ComputeMove(Position dest) { var move = new Move { Pos = new Position { X = dest.X - this.Speed.Vx, Y = dest.Y - this.Speed.Vy } }; // Acc var dist = this.Pos.Dist(move.Pos); if (Math.Abs(dist) <= 0.0001) { return(move); } //var expectedVx = Math.Abs(move.Pos.X - this.Pos.X) / (1 - this.Friction); //var expectedVy = Math.Abs(move.Pos.Y - this.Pos.Y) / (1 - this.Friction); //var accX = (int)Math.Round(expectedVx * dist * this.Mass); //var accY = (int)Math.Round(expectedVy * dist * this.Mass); //Program.ConsoleHelper.Debug($"accX={accX}|accY={accY}"); //move.Acc = Math.Min((accX + accY) / 2, 300); var acc = (int)Math.Round(this.Mass * dist); move.Acc = Math.Min(acc, 300); return(move); }
public static double SolveParam_2(double len, double r1, double r2) { Func <double, double> f = (a) => { double fs1, fc1; FresnelUtils.Fresnel(a / (r1 * sqrtpi), out fs1, out fc1); double fs2, fc2; FresnelUtils.Fresnel(a / (r2 * sqrtpi), out fs2, out fc2); double fc21 = (fc2 - fc1); double fs21 = (fs2 - fs1); return(a * a * SysMath.PI * (fc21 * fc21 + fs21 * fs21) - len * len); }; int maxEval = 50; // 30 try { double min = 0; double max = SysMath.Min(SysMath.Abs(r1), SysMath.Abs(r2)) * MAX_L; return(Solver.Solve(f, min, max, Solver.Type.Brent, Solver.DEFAULT_ABSOLUTE_ACCURACY, maxEval)); } catch (Exception e) { Debug.WriteLine(e); throw; } }
public void GenerateWater(VoxelChunk chunk, float maxHeight) { int waterHeight = Math.Min((int)(VoxelConstants.ChunkSizeY * NormalizeHeight(SeaLevel + 1.0f / VoxelConstants.ChunkSizeY, maxHeight)), VoxelConstants.ChunkSizeY - 1); var iceID = VoxelLibrary.GetVoxelType("Ice"); for (var x = 0; x < VoxelConstants.ChunkSizeX; ++x) { for (var z = 0; z < VoxelConstants.ChunkSizeZ; ++z) { var biome = Overworld.GetBiomeAt(new Vector3(x, 0, z) + chunk.Origin, chunk.Manager.World.WorldScale, chunk.Manager.World.WorldOrigin); var topVoxel = VoxelHelpers.FindFirstVoxelBelow(new VoxelHandle( chunk, new LocalVoxelCoordinate(x, VoxelConstants.ChunkSizeY - 1, z))); for (var y = 0; y <= waterHeight; ++y) { var vox = new VoxelHandle(chunk, new LocalVoxelCoordinate(x, y, z)); if (vox.IsEmpty && y > topVoxel.Coordinate.Y) { if (biome.WaterSurfaceIce && y == waterHeight) { vox.RawSetType(iceID); } else { vox.QuickSetLiquid(biome.WaterIsLava ? LiquidType.Lava : LiquidType.Water, WaterManager.maxWaterLevel); } } } } } }
public static void SetHeight(float[,] heightMap, Vector2 pos, float height) { int x = Math.Max(Math.Min((int)pos.X, heightMap.GetLength(0) - 1), 0); int y = Math.Max(Math.Min((int)pos.Y, heightMap.GetLength(1) - 1), 0); heightMap[x, y] = height; }
/// <summary> /// Create beacon message /// </summary> /// <param name="msgBytes"></param> /// <param name="etx">Estimated distance from Base</param> /// <param name="beaconNum">Beacon sequence counter</param> /// <returns>Size of message</returns> public static int CreateBeacon(byte[] msgBytes, byte etx, ushort beaconNum, byte ewmarnp, ushort parent) { var idx = 0; msgBytes[idx] = (byte)MessageIds.Beacon; idx += sizeof(byte); //Debug.Print("\tIdx: " + idx); msgBytes[idx] = etx; idx += sizeof(byte); //Debug.Print("\tIdx: " + idx); var beaconAdj = (ushort)Math.Min(beaconNum, ushort.MaxValue); BitConverter.InsertValueIntoArray(msgBytes, idx, beaconAdj); idx += sizeof(ushort); msgBytes[idx] = ewmarnp; idx += sizeof(byte); BitConverter.InsertValueIntoArray(msgBytes, idx, parent); idx += sizeof(ushort); return(idx); }
public static float GetValue(MapData[,] map, Vector2 pos, ScalarFieldType value) { int x = Math.Max(Math.Min((int)pos.X, map.GetLength(0) - 1), 0); int y = Math.Max(Math.Min((int)pos.Y, map.GetLength(1) - 1), 0); return(map[x, y].GetValue(value)); }
public void EmitLoadAddress(Format12OpCode opCode, LowRegister targetRegister, int target, bool thumbAdjustment) { var offset = target - ((CurrentAddress + 4) & ~2); if (offset >= 0) { Emit(opCode, targetRegister, target); if (thumbAdjustment) { Emit(Format3OpCode.ADD, targetRegister, 1); } } else { //While the Format12 instruction will clear the 1 bit of the PC, this code does not var remainder = -(target - (CurrentAddress + 4)); if (thumbAdjustment) { --remainder; } Emit(Format5OpCode.MOV, targetRegister, Register.PC); while (remainder != 0) { var amountToUse = Math.Min(remainder, 255); Emit(Format3OpCode.SUB, targetRegister, (byte)remainder); remainder -= amountToUse; } } }
public static void AddValue(MapData[,] map, Vector2 pos, ScalarFieldType value, float amount) { int x = Math.Max(Math.Min((int)pos.X, map.GetLength(0) - 1), 0); int y = Math.Max(Math.Min((int)pos.Y, map.GetLength(1) - 1), 0); map[x, y].SetValue(value, map[x, y].GetValue(value) + amount); }
public static List <Vector3Int> MakeWalls(WorldEdit.AreaSelection area, int border = 1) { List <Vector3Int> affected = new List <Vector3Int>(); int minX = Math.Min(area.posA.x, area.posB.x); int maxX = Math.Max(area.posA.x, area.posB.x); int minZ = Math.Min(area.posA.z, area.posB.z); int maxZ = Math.Max(area.posA.z, area.posB.z); Vector3Int relative; for (int x = area.cornerB.x; x >= area.cornerA.x; x--) { for (int y = area.cornerB.y; y >= area.cornerA.y; y--) { for (int z = area.cornerB.z; z >= area.cornerA.z; z--) { relative = new Vector3Int(x, y, z); if (relative.x > (maxX - border) || relative.x < (minX + border) || relative.z > (maxZ - border) || relative.z < (minZ + border)) { affected.Add(relative); } } } } return(affected); }
/// <summary> /// Resuelve el parametro de la clotoide dado los radios <c>r0</c> y <c>r1</c> Con una distancia <c>d</c> entre los /// puntos. /// </summary> private static double SolveParam(double d, double r0, double r1) { Func <double, double> f = (a) => { double fs0, fc0; ClothoUtils.Fresnel(a / (r0 * sqrtpi), out fs0, out fc0); double fs1, fc1; ClothoUtils.Fresnel(a / (r1 * sqrtpi), out fs1, out fc1); double fc10 = (fc1 - fc0); double fs10 = (fs1 - fs0); return(a * a * SysMath.PI * (fc10 * fc10 + fs10 * fs10) - d * d); }; int maxEval = 50; // 30 try { double min = 0; double max = SysMath.Min(SysMath.Abs(r0), SysMath.Abs(r1)) * ClothoUtils.MAX_L; double v = Solver.Solve(f, min, max, Solver.Type.BrentSolver, DEFAULT_ABSOLUTE_ACCURACY, maxEval); return(v); } catch (Exception e) { Debug.WriteLine(e); throw; } }
/// <summary> /// Transfers resources into the specified parts /// </summary> /// <param name="parts">All of the recipient parts</param> /// <param name="pulledAmount">the aggregate amount we are seeking to add to the parts</param> private void PutResources(IList <global::Part> parts, double pulledAmount) { var retries = 0; var evenShare = pulledAmount / parts.Count; var remaining = pulledAmount; while (remaining > 0.0001) { if (retries > 10) { MarkFailed("Error in putting resource with " + remaining + " remaining."); break; } foreach (var part in parts) { var resource = part.Resources.Get(resourceInfo.id); if (resource == null) { continue; } var transferAmount = Math.Min(remaining, evenShare); remaining += part.TransferResource(resource.info.id, transferAmount); } retries++; } }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns>true if the current object is equal to the <paramref name="other" /> parameter; otherwise, false.</returns> public bool Equals(PolarCoordinate other) { double tolerance = NMath.Min(Tolerance, other.Tolerance); return(Azimuth.Radians.IsEqualTo(other.Azimuth.Radians, tolerance) && Radius.IsEqualTo(other.Radius, tolerance)); }
/// <summary> /// Implements the + operator. /// </summary> /// <param name="point1">The point1.</param> /// <param name="point2">The point2.</param> /// <returns>The result of the operator.</returns> public static PolarCoordinate operator +(PolarCoordinate point1, PolarCoordinate point2) { return(new PolarCoordinate( point1.Radius + point2.Radius, point1.Rotation + point2.Rotation, NMath.Min(point1.Tolerance, point2.Tolerance))); }