public static void AddLane(Curve3DSampler l, out List <Lane> added, out List <Lane> deleted) { // Variable has not been actually calculated until "ToList()" is called var lane_intersections = from lane in allLanes let intersections = lane.IntersectWith(l) where intersections.Count > 0 select(lane, intersections); if (lane_intersections.ToList().Count > 0) { Debug.Log("From " + allLanes.Count + " found # intersections: " + lane_intersections.ToList()[0].intersections.Count); } added = new List <Lane>(); deleted = new List <Lane>(); List <float> l_intersect_params = new List <float>(); // replacements foreach (var lane_intersection in lane_intersections.ToList()) { Lane old_lane; List <Vector3> intersection; (old_lane, intersection) = lane_intersection; List <float> intersection_params = intersection.ConvertAll(input => old_lane.xz_curve.ParamOf(Algebra.toVector2(input)).Value); List <Curve3DSampler> splitted = old_lane.MultiCut(intersection_params, old_lane.xz_curve.Length); //remove old lanes & destroy objects. old_lane.SetGameobjVisible(false); allLanes.Remove(old_lane); deleted.Add(old_lane); //create replacements var replaced_lanes = splitted.ConvertAll(sampler => new Lane(sampler)); added.AddRange(replaced_lanes); //store intersection points on l intersection.ForEach(input => l_intersect_params.Add(l.xz_curve.ParamOf(Algebra.toVector2(input)).Value)); } // create new lane List <Curve3DSampler> l_splitted = l.MultiCut(l_intersect_params, l.xz_curve.Length); var new_lanes = l_splitted.ConvertAll(sampler => new Lane(sampler)); added.AddRange(new_lanes); Debug.Log(new_lanes.Count + "newly added"); // Update record allLanes.AddRange(added); OnMapChanged?.Invoke(null, allLanes); }
public static Curve TryInit(Vector2 _start, float angle, Vector2 _end, float _z_start = 0f, float _z_end = 0f) { Arc candidate = new Arc(_start, angle, _end, _z_start, _z_end); if (Algebra.isclose(candidate.length, 0f)) { return(null); } else { return(candidate); } }
public void Reduce() { long GDC = Algebra.GreatestCommonDivisor(Numerator, Denominator); Numerator /= GDC; Denominator /= GDC; if (Denominator < 0) { Denominator *= -1; Numerator *= -1; } }
/// <summary> /// tries to return the one dimensional array 'targert' to its original two dimensional array. /// </summary> /// <param name="target"></param> /// <returns></returns> public static T[,] Expande(T[] target, int firstDimension) { T[,] r = new T[firstDimension, Algebra.Round(target.Length / firstDimension)]; int target_index = 0;; for (int i = 0; i < firstDimension; i++) { for (int j = 0; j < r.GetLength(1); j++, target_index++) { r[i, j] = target[target_index]; } } return(r); }
private void BtnCubeRoot_Click(object sender, EventArgs e) { //if there's input call the Third library and perform the cube root function if (CheckForInput(tbResult.Text)) { tbResult.Text = Algebra.CubeRoot(double.Parse(tbResult.Text)).ToString(); isTotal = true; } //if there's no input or input is invalid print error to user else { MessageBox.Show("Please enter valid input"); } }
public FiniteFieldElement <IntegerType> [] GetElements() { if (1000000 < ElementCount) { throw new Exception("Groups is to big, you do not want this"); } FiniteFieldElement <IntegerType> [] elements = new FiniteFieldElement <IntegerType> [(int)ElementCount]; for (int index = 0; index < elements.Length; index++) { elements[index] = new FiniteFieldElement <IntegerType>(this, Algebra.ToDomain(index)); } return(elements); }
public static Curve TryInit(Vector3 _center, Vector3 _start, float angle) { Arc candidate = new Arc(_center, _start, angle); if (Algebra.isclose(candidate.length, 0f)) { Debug.LogWarning("try creating Arc of zero length!"); return(null); } else { return(candidate); } }
public static Curve TryInit(Vector3 _start, Vector3 _end) { Line candidate = new Line(_start, _end); if (Algebra.isclose(candidate.length, 0f)) { Debug.LogWarning("try creating Line of zero length!"); return(null); } else { return(candidate); } }
public void DoAlgebra() { SetWork(new Steps(equation)); if (IsTimeKnown()) { Algebra.solveEquation(false, this.work, leftSide, rightSide, GetMissingQuantityIndex()); } else { Algebra.solveEquation(true, this.work, leftSide, rightSide, GetMissingQuantityIndex()); } SetQuantity(GetMissingQuantityIndex(), this.work.GetNumericalAnswer().ToString()); //adds answer to array and updates knowns }
public void TestDiagonal() { var a = new DenseDoubleMatrix2D(new[] { new[] { 5d, 2d, 4d }, new[] { -3d, 6d, 2d }, new[] { 3d, -3d, 1d } }); var principal = DoubleFactory2D.Dense.Diagonal(a); Assert.AreEqual(5d, principal[0]); Assert.AreEqual(6d, principal[1]); Assert.AreEqual(1d, principal[2]); Assert.AreEqual(12d, Algebra.Trace(a)); }
public void DoAlgebra() { SetWork(new Steps(equation)); if (!IsTimeKnown()) { Algebra.getPositiveQuadraticRoot(work, 0.5f * GetNumericalQuantity(3), GetNumericalQuantity(0), -1 * GetNumericalQuantity(4)); } else { Algebra.solveEquation(false, work, leftSide, rightSide, GetMissingQuantityIndex()); } SetQuantity(GetMissingQuantityIndex(), this.work.GetNumericalAnswer().ToString()); //adds answer to array and updates knowns }
public bool findNodeAt(Vector3 position, out Node rtn) { Vector3 approx = Algebra.approximate(position); if (allnodes.ContainsKey(approx)) { rtn = allnodes[approx]; return(true); } else { rtn = null; return(false); } }
public bool contains(Vector3 point) { Vector2 twod_point = new Vector2(point.x, point.z); //Debug.Log("param of " + point + " is " + paramOf(twod_point)); if (paramOf(twod_point) != null && 0 <= (float)paramOf(twod_point) && (float)paramOf(twod_point) <= 1f) { //Debug.Log((this.at((float)paramOf(twod_point)) - point).magnitude.ToString("C4")); return(Algebra.isclose(this.at((float)paramOf(twod_point)), point)); } else { return(false); } }
public void NewTestScriptSimplePasses() { Curve c = Arc.TryInit(roadPoints[0], roadPoints[1], Mathf.PI / 2); Curve cr = c.reversed(); Assert.True(Algebra.isclose(c.At(0f), cr.At(1f))); float a1 = c.Angle_2d(1f); float a2 = cr.Angle_2d(0f); //float angleDiff = (a2 - a1) / Mathf.PI; Debug.Log(a1); Debug.Log(a2); Assert.True(Algebra.isclose(a2, Mathf.PI / 2)); }
/// <summary> /// Attracts the p to curve. Default implementation uses a binary search /// </summary> /// <returns>If the curve is not in radius distance, then just return p</returns> public virtual Vector2 GetAttractedPoint(Vector2 p, float attract_radius) { Algebra.Del _Distance = (t) => (_GetTwodPos(t) - p).sqrMagnitude; float close_scaled_t = Algebra.MinArg(_Distance, 0.5f, 0f, 1f); Vector2 closest_p = _GetTwodPos(close_scaled_t); if ((closest_p - p).sqrMagnitude <= attract_radius * attract_radius) { return(closest_p); } else { return(p); } }
/// <summary> /// <para> start turns angle clockwise around center and arrives at end</para> /// </summary> /// <param name="angle">Can be negative</param> public Arc(Vector2 start, float angle, Vector2 end) { Debug.Assert(Mathf.Abs(angle) < Mathf.PI * 2); controlPoints = new Vector2[3]; var bottom_angle = (Mathf.PI - angle) * 0.5f; Center = start + Algebra.RotatedY(end - start, -bottom_angle) * 0.5f / Mathf.Sin(angle / 2); Radius = (Center - start).magnitude; var radialDir = start - Center; t_start = Mathf.Atan2(radialDir.y, radialDir.x); t_end = t_start + angle; Start = GetTwodPos(0f); End = GetTwodPos(1f); }
/*<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ /*inverse of lengthByParam*/ public float ParamByLength(float l, bool usebuff = false) { if (usebuff) { //return paramByLengthBuffer[Mathf.CeilToInt(l / bufferResolution)]; int a = Mathf.FloorToInt(l / bufferResolution); int b = a + 1; float aLength = a * Length / (bufferLength - 1); float bLength = b * Length / (bufferLength - 1); return(Algebra.genericScalarIntepolator(paramByLengthBuffer[a], paramByLengthBuffer[b], l - aLength, bLength - l)); } else { return(paramByLength(l)); } }
/*<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ /*curve's length from param 0 to param t*/ public float LengthByParam(float t, bool usebuff = false) { if (usebuff && 0 <= t && t <= 1) { //return lengthByParamBuffer[Mathf.CeilToInt(t * length / bufferResolution)]; int a = Mathf.FloorToInt(t * Length / bufferResolution); int b = a + 1; float aParam = a * 1f / (bufferLength - 1); float bParam = b * 1f / (bufferLength - 1); return(Algebra.genericScalarIntepolator(lengthByParamBuffer[a], lengthByParamBuffer[b], t - aParam, bParam - t)); } else { return(lengthByParam(t)); } }
/*<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ public Vector3 FrontNormal(float t, bool usebuff = false) { if (usebuff && 0 <= t && t <= 1) { //return frontNormalBuffer[Mathf.CeilToInt(t * length / bufferResolution)]; int a = Mathf.FloorToInt(t * Length / bufferResolution); int b = a + 1; float aParam = a * 1f / (bufferLength - 1); float bParam = b * 1f / (bufferLength - 1); return(Algebra.unitVecInterpolator(frontNormalBuffer[a], frontNormalBuffer[b], t - aParam, bParam - t)); } else { return(frontNormal(t)); } }
/// <summary> /// /// </summary> /// <param name="point1"></param> /// <param name="point2"></param> /// <param name="radius"></param> /// <returns></returns> public static Point[] CircleLineIntersect(Point point1, Point point2, double radius) { Offset delta = new Offset(point1, point2); double determinant = point1.CrossProduct(point2); double lineLength = Algebra.SRSS(delta.X(), delta.Y()); double incidence = incidenceLineCircle(radius, lineLength, determinant); double[] xCoords = CircleLineIntersectX(radius, lineLength, incidence, determinant, delta); double[] yCoords = CircleLineIntersectY(radius, lineLength, incidence, determinant, delta); return(new[] { new Point(xCoords[0], yCoords[0]), new Point(xCoords[1], yCoords[1]) }); }
/*resulting curve: Length = Original * (end - start)*/ public Curve cut(float start, float end) { end = Mathf.Max(start, end); if (this is Line || this is Arc) { Curve rtn; if (start < 0f && !Algebra.isclose(start, 0f) || end > 1f && !Algebra.isclose(end, 1f)) { Debug.Log("Abnormal cut, start:" + start + "end:" + end); throw new InvalidOperationException(); } Curve secondAndThird = Algebra.isclose(start, 0f) ? this : split(start).Last(); if (!Algebra.isclose(end, 1f)) { Curve third = split(end).Last(); float secondFraction = (secondAndThird.length - third.length) / secondAndThird.length; rtn = secondAndThird.split(secondFraction).First(); } else { if (!Algebra.isclose(start, 0f)) { rtn = secondAndThird; } else { rtn = segmentation(this.length).First(); } } if (Mathf.Abs(rtn.at(0f).y - this.at(end).y) < Mathf.Abs(rtn.at(1f).y - this.at(end).y)) { rtn.reverse(); rtn.z_start = rtn.z_start + rtn.z_offset; rtn.z_offset = -rtn.z_offset; } return(rtn); } else { Vector2 p1 = this.at_ending_2d(true, start * length); Vector2 p2 = this.at_ending_2d(false, (1f - end) * length); Curve rtn = deepCopy(); rtn.t_start = toGlobalParam(paramOf(p1).Value); rtn.t_end = toGlobalParam(paramOf(p2).Value); return(rtn); } }
public void DoAlgebra() { Expression leftSide = new UnaryExpression(GetQuantity(4)); Expression rightSide = new BinaryExpression(new BinaryExpression(new UnaryExpression(GetQuantity(1)), new UnaryExpression(GetQuantity(2)), '*'), new BinaryExpression(new BinaryExpression("0.5", new UnaryExpression(GetQuantity(3)), '*'), new BinaryExpression(new UnaryExpression(GetQuantity(2)), "2", '^'), '*'), '-'); SetWork(new Steps(equation)); if (!IsTimeKnown()) { Algebra.getPositiveQuadraticRoot(work, -0.5f * GetNumericalQuantity(3), GetNumericalQuantity(1), -1 * GetNumericalQuantity(4)); } else { Algebra.solveEquation(false, this.work, leftSide, rightSide, GetMissingQuantityIndex()); } SetQuantity(GetMissingQuantityIndex(), this.work.GetNumericalAnswer().ToString()); //adds answer to array and updates knowns }
public void AreCoprime() { Algebra.AreCoprime(6, 1).ShouldBeTrue(); Algebra.AreCoprime(6, 5).ShouldBeTrue(); Algebra.AreCoprime(6, 2).ShouldBeFalse(); Algebra.AreCoprime(6, 3).ShouldBeFalse(); Algebra.AreCoprime(6, 4).ShouldBeFalse(); Algebra.AreCoprime(6, 6).ShouldBeFalse(); Algebra.AreCoprime(-2, 4).ShouldBeFalse(); Algebra.AreCoprime(-2, -4).ShouldBeFalse(); Algebra.AreCoprime(2, -4).ShouldBeFalse(); Algebra.AreCoprime(-2, 3).ShouldBeTrue(); Algebra.AreCoprime(-2, -3).ShouldBeTrue(); Algebra.AreCoprime(2, -3).ShouldBeTrue(); }
private static WriteableBitmap CubeH(int cubeWidth, double columnY) { Algebra.DividePlane(cubeWidth, cubeWidth, _cores, out var dic); var length = dic.Count; var stride = cubeWidth * 4; var a = new byte[stride * cubeWidth]; var step = 1.0 / cubeWidth; var h = 360.0 - columnY * 360.0; Parallel.For(0, length, i => { var d = dic[i]; var str = stride; for (var y = d[1]; y < d[1] + d[3]; y++) { for (var x = d[0]; x < d[0] + d[2]; x++) { var n = y * str + x * 4; var hsb = new Hsb { H = h, S = step * x, B = 1.0 - step * y }; var rgb = hsb.To <Rgb>(); var r = (byte)Math.Round(rgb.R); var g = (byte)Math.Round(rgb.G); var b = (byte)Math.Round(rgb.B); a[n] = b; a[n + 1] = g; a[n + 2] = r; a[n + 3] = 255; } } }); var rect = new Int32Rect(0, 0, cubeWidth, cubeWidth); var img = new WriteableBitmap(cubeWidth, cubeWidth, 96, 96, PixelFormats.Bgr32, null); img.Lock(); img.WritePixels(rect, a, stride, 0); img.Unlock(); img.Freeze(); return(img); }
public static void Test() { Console.WriteLine(); Console.WriteLine("AlgebraExt test"); var evalExpr = CreateTestExprExt(new EvalAlgebraExt()); Console.WriteLine($" 4 * (5 + 6) = {evalExpr.Eval()}"); var printExprA = Algebra.CreateTestExpr(new PrintAlgebra()); Console.WriteLine($" Print: {printExprA.Print()}"); var printExprB = CreateTestExprExt(new PrintAlgebra()); Console.WriteLine($" Print: {printExprB.Print()}"); }
void drawLinear2DObject(Curve curve, Linear2DObject sep) { float margin_0 = sep.margin_0; float margin_1 = sep.margin_1; if (Algebra.isclose(margin_0 + margin_1, curve.length)) { return; } Debug.Assert(margin_0 + margin_1 < curve.length); if (margin_0 + margin_1 > curve.length) { return; } if (curve.length > 0 && (margin_0 > 0 || margin_1 > 0)) { curve = curve.cut(margin_0 / curve.length, 1f - margin_1 / curve.length); } if (!sep.dashed) { GameObject rendins = Instantiate(rend, transform); CurveRenderer decomp = rendins.GetComponent <CurveRenderer> (); decomp.CreateMesh(curve, sep.width, sep.material, offset: sep.offset, z_offset: 0.02f); } else { List <Curve> dashed = curve.segmentation(dashLength + dashInterval); if (!Algebra.isclose(dashed.Last().length, dashLength + dashInterval)) { dashed.RemoveAt(dashed.Count - 1); } foreach (Curve singledash in dashed) { List <Curve> vacant_and_dashed = singledash.split(dashInterval / (dashLength + dashInterval)); if (vacant_and_dashed.Count == 2) { GameObject rendins = Instantiate(rend, transform); CurveRenderer decomp = rendins.GetComponent <CurveRenderer> (); decomp.CreateMesh(vacant_and_dashed [1], sep.width, sep.material, offset: sep.offset, z_offset: 0.02f); } } } }
void addAngleDrawing(Vector3 positionMaybeOnRoad, Vector3 anotherPosition) { Node n; List <Vector2> neighborDirs; if (roadManager.findNodeAt(positionMaybeOnRoad, out n)) { neighborDirs = n.getNeighborDirections(Algebra.toVector2(anotherPosition - positionMaybeOnRoad)); } else { Road tar; roadManager.approxNodeToExistingRoad(positionMaybeOnRoad, out tar); if (tar == null) { return; } float?param = tar.curve.paramOf(positionMaybeOnRoad); if (param == null) { return; } neighborDirs = new List <Vector2>() { tar.curve.direction_2d((float)param), -tar.curve.direction_2d((float)param) }; } foreach (Vector2 dir in neighborDirs) { Debug.Assert(!Algebra.isclose(dir, Vector2.zero)); Vector3 textPosition = positionMaybeOnRoad + ((anotherPosition - positionMaybeOnRoad).normalized + Algebra.toVector3(dir).normalized).normalized * textDistance; GameObject textObj = Instantiate(degreeTextPrefab, textPosition, Quaternion.Euler(90f, 0f, 0f)); textObj.transform.SetParent(transform); textObj.GetComponent <TextMesh>().text = Mathf.RoundToInt(Mathf.Abs(Vector2.Angle(Algebra.toVector2(anotherPosition - positionMaybeOnRoad), dir))).ToString(); degreeTextInstance.Add(textObj); GameObject indicatorObj = Instantiate(roadIndicatorPrefab, transform); RoadRenderer indicatorConfigure = indicatorObj.GetComponent <RoadRenderer>(); indicatorConfigure.generate(Line.TryInit(positionMaybeOnRoad, positionMaybeOnRoad + Algebra.toVector3(dir) * textDistance * 2), new List <string> { "solid_blueindi" }); neighborIndicatorInstance.Add(indicatorObj); } }
internal List <Vector2> getNeighborDirections(Vector2 direction) { if (connection.Count <= 2) { return(connection.ConvertAll((input) => input.curve.direction_ending_2d(startof(input.curve)))); } List <float> anglesFromDirection = connection.ConvertAll((input) => Algebra.signedAngleToPositive(Vector2.SignedAngle(direction, input.curve.direction_ending_2d(startof(input.curve))))); return(connection.FindAll((Road arg1) => Algebra.signedAngleToPositive(Vector2.SignedAngle(direction, arg1.curve.direction_ending_2d(startof(arg1.curve)))) == anglesFromDirection.Max() || Algebra.signedAngleToPositive(Vector2.SignedAngle(direction, arg1.curve.direction_ending_2d(startof(arg1.curve)))) == anglesFromDirection.Min()). ConvertAll((input) => input.curve.direction_ending_2d(startof(input.curve)))); }
private void createOrAddtoNode(Road road) { List <Vector3> roadEnds = new List <Vector3> { road.curve.at(0f), road.curve.at(1f) }; foreach (Vector3 roadEnd in roadEnds) { Node candidate; if (!findNodeAt(roadEnd, out candidate)) { candidate = Instantiate(nodePrefab, transform).GetComponent <Node>(); candidate.position = roadEnd; allnodes.Add(Algebra.approximate(roadEnd), candidate); } candidate.addRoad(road); } }
/*If angle>0, * angle is in radius */ private Arc(Vector2 _center, Vector2 start, float angle, float _z_start = 0f, float _z_end = 0f) { center = _center; radius = (start - _center).magnitude; float t_0 = Mathf.Acos((start.x - _center.x) / radius); /*[0, Pi]*/ if (!Algebra.isclose(Mathf.Sin(t_0), (start.y - center.y) / radius)) { t_0 = -t_0;/*[-Pi, 0]*/ } Debug.Assert(Mathf.Abs(t_0) <= Mathf.PI); t_start = t_0; t_end = t_start + angle; z_start = _z_start; z_offset = _z_end - _z_start; }