static void Main(string[] args)
{
//ShapeBase shape = new ShapeBase();
Triangle triangle = new Triangle(3, 4, 5);
Console.WriteLine(triangle.Name);
Console.WriteLine(triangle.GetPerimeter());
Console.WriteLine(triangle.GetSquare());
IsoscelesTriangle triangle2 = new IsoscelesTriangle(5, 4);
Console.WriteLine(triangle2.Name);
Console.WriteLine(triangle2.GetPerimeter());
Console.WriteLine(triangle2.GetSquare());
EquilateralTriangle triangle3 = new EquilateralTriangle(3);
Console.WriteLine(triangle3.Name);
Console.WriteLine(triangle3.GetPerimeter());
Console.WriteLine(triangle3.GetSquare());
RectangularTriangle triangle4 = new RectangularTriangle(3, 4);
Console.WriteLine(triangle4.Name);
Console.WriteLine(triangle4.GetPerimeter());
Console.WriteLine(triangle4.GetSquare());
Console.ReadKey();
}
static void Main(string[] args)
{
try
{
RectangularTriangle rectTriangle1 = new RectangularTriangle(4, 5);
RectangularTriangle rectTriangle2 = new RectangularTriangle(3, 4);
//Calculate area and perimeter of rectTriangle1
Console.WriteLine($"rectTriangle1`s area: {rectTriangle1.CalculateArea()}");
Console.WriteLine($"rectTriangle1`s perimeter: {rectTriangle1.CalculatePerimeter()}");
//Calculate area and perimeter of rectTriangle2
Console.WriteLine($"rectTriangle2`s area: {rectTriangle2.CalculateArea()}");
Console.WriteLine($"rectTriangle2`s perimeter: {rectTriangle2.CalculatePerimeter()}");
IsoscelesTriangle isoscTriangle1 = new IsoscelesTriangle(3, 60);
IsoscelesTriangle isoscTriangle2 = new IsoscelesTriangle(6, 60);
// Calculate area and perimeter of isoscTriangle1
Console.WriteLine($"isoscTriangle1`s area: {isoscTriangle1.CalculateArea()}");
Console.WriteLine($"isoscTriangle1`s perimeter: {isoscTriangle1.CalculatePerimeter()}");
// Calculate area and perimeter of isoscTriangle2
Console.WriteLine($"isoscTriangle2`s area: {isoscTriangle2.CalculateArea()}");
Console.WriteLine($"isoscTriangle2`s perimeter: {isoscTriangle2.CalculatePerimeter()}");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public static void Area()
{
IsoscelesTriangle triangle = new IsoscelesTriangle(6, 4);
double area = triangle.Area();
Assert.AreEqual(11.31371, area, Tolerance);
}
/// <summary>
/// Figure out which triangles we can choose from before the window is shown.
/// </summary>
protected override void OnShow()
{
List <GroundedClause> givens = new List <GroundedClause>();
//Populate list with applicable givens
foreach (GroundedClause gc in currentGivens)
{
IsoscelesTriangle it = gc as IsoscelesTriangle;
if (it != null)
{
givens.Add(it);
}
}
List <Triangle> isosTriangles = new List <Triangle>();
//Populate list with possible choices
foreach (Triangle t in parser.backendParser.implied.polygons[GeometryTutorLib.ConcreteAST.Polygon.TRIANGLE_INDEX])
{
if (isIsosceles(t))
{
IsoscelesTriangle it = new IsoscelesTriangle(t);
if (!StructurallyContains(givens, it))
{
isosTriangles.Add(it);
}
}
}
options.ItemsSource = null; //Makes sure the box is graphically updated.
options.ItemsSource = isosTriangles;
}
public void TestIsoscelesTriangle(int x1, int y1, int x2, int y2, int[] ExPoints)
{
IsoscelesTriangle Actual = new IsoscelesTriangle();
bool ActualPoint = Actual.CheckForMatches(x1, y1, x2, y2, 0, ExPoints);
bool Expected = true;
Assert.AreEqual(Expected, ActualPoint);
}
public void Create_IsoscelesTriangleForInvalidData_TriangleTypeException()
{
// arrange
var sides = ReadTriangleSidesFromTestContext();
// act
var res = new IsoscelesTriangle(sides);
// assert
}
public static void LocalCoordinates()
{
IsoscelesTriangle triangle = new IsoscelesTriangle(6, 4);
IList <CartesianCoordinate> coordinates = triangle.LocalCoordinates();
Assert.AreEqual(3, coordinates.Count);
Assert.AreEqual(triangleCoordinates[0].X, coordinates[0].X);
Assert.AreEqual(triangleCoordinates[0].Y, coordinates[0].Y, Tolerance);
Assert.AreEqual(triangleCoordinates[1], coordinates[1]);
Assert.AreEqual(triangleCoordinates[2], coordinates[2]);
}
public void Create_IsoscelesTriangleForValidData_IsIsoscelesTriangle()
{
// arrange
var sides = ReadTriangleSidesFromTestContext();
// act
var res = new IsoscelesTriangle(sides);
// assert
Assert.IsInstanceOfType(res, typeof(IsoscelesTriangle));
}
static void Main(string[] args)
{
Shape f1, f2;
f1 = new IsoscelesTriangle(10, 10, 10);
double a = f1.GetАrea();
string b = f1.GetName();
f2 = new Square(10);
double a1 = f2.GetАrea();
string a2 = f2.GetName();
}
public static List <GenericInstantiator.EdgeAggregator> GeneratePerpendicularBisector(GroundedClause tri, AngleBisector ab, Intersection inter)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
IsoscelesTriangle isoTri = (tri is Strengthened ? (tri as Strengthened).strengthened : tri) as IsoscelesTriangle;
if (tri is EquilateralTriangle)
{
}
// Does the Angle Bisector occur at the vertex angle (non-base angles) of the Isosceles triangle?
try
{
if (!ab.angle.GetVertex().Equals(isoTri.GetVertexAngle().GetVertex()))
{
return(newGrounded);
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.ToString());
}
// Is the intersection point between the endpoints of the base of the triangle?
if (!Segment.Between(inter.intersect, isoTri.baseSegment.Point1, isoTri.baseSegment.Point2))
{
return(newGrounded);
}
// Does this intersection define this angle bisector situation? That is, the bisector and base must align with the intersection
if (!inter.ImpliesRay(ab.bisector))
{
return(newGrounded);
}
if (!inter.HasSegment(isoTri.baseSegment))
{
return(newGrounded);
}
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(tri);
antecedent.Add(ab);
antecedent.Add(inter);
// PerpendicularBisector(M, Segment(M, C), Segment(A, B))
Strengthened newPerpB = new Strengthened(inter, new PerpendicularBisector(inter, ab.bisector));
newGrounded.Add(new EdgeAggregator(antecedent, newPerpB, annotation));
return(newGrounded);
}
public override ShapeBase Clone()
{
var shape = new IsoscelesTriangle
{
Location = Location,
Size = Size,
DrawMethod = DrawMethod,
OutlineColor = OutlineColor,
OutlineWidth = OutlineWidth,
FillColor = FillColor,
IsClosedFigure = IsClosedFigure,
Vertices = (VertexCollection)Vertices.Clone()
};
return(shape);
}
public static void Initialization_with_Apex_Coordinate_Creates_Shape()
{
IsoscelesTriangle triangle = new IsoscelesTriangle(triangleCoordinates[0]);
Assert.AreEqual(GeometryLibrary.ZeroTolerance, triangle.Tolerance);
Assert.AreEqual(3, triangle.Points.Count);
Assert.AreEqual(triangleCoordinates[0].X, triangle.SideA.I.X);
Assert.AreEqual(triangleCoordinates[0].Y, triangle.SideA.I.Y, Tolerance);
Assert.AreEqual(triangleCoordinates[1], triangle.SideA.J);
Assert.AreEqual(triangleCoordinates[1], triangle.SideB.I);
Assert.AreEqual(triangleCoordinates[2], triangle.SideB.J);
Assert.AreEqual(triangleCoordinates[2], triangle.SideC.I);
Assert.AreEqual(triangleCoordinates[0].X, triangle.SideC.J.X);
Assert.AreEqual(triangleCoordinates[0].Y, triangle.SideC.J.Y, Tolerance);
Assert.AreEqual(3, triangle.Sides.Count);
Assert.AreEqual(6, triangle.SideA.Length(), Tolerance);
Assert.AreEqual(4, triangle.SideB.Length(), Tolerance);
Assert.AreEqual(6, triangle.SideC.Length(), Tolerance);
Assert.AreEqual(3, triangle.Angles.Count);
Assert.AreEqual(70.52878175, triangle.AngleA.Degrees, Tolerance);
Assert.AreEqual(38.94243649, triangle.AngleB.Degrees, Tolerance);
Assert.AreEqual(70.52878175, triangle.AngleC.Degrees, Tolerance);
Assert.AreEqual(5.65686, triangle.h, Tolerance);
Assert.AreEqual(2, triangle.Centroid.X, Tolerance);
Assert.AreEqual(1.885618333, triangle.Centroid.Y, Tolerance);
Assert.AreEqual(2, triangle.OrthoCenter.X, Tolerance);
Assert.AreEqual(0.707106687, triangle.OrthoCenter.Y, Tolerance);
Assert.AreEqual(3.181980844, triangle.CircumRadius, Tolerance);
Assert.AreEqual(2, triangle.CircumCenter.X, Tolerance);
Assert.AreEqual(2.474874156, triangle.CircumCenter.Y, Tolerance);
Assert.AreEqual(1.414213625, triangle.InRadius, Tolerance);
Assert.AreEqual(2, triangle.InCenter.X, Tolerance);
Assert.AreEqual(1.414213625, triangle.InCenter.Y, Tolerance);
}
public void Visit(IsoscelesTriangle triangle)
{
Console.WriteLine($"Isosceles triangle with leg={triangle.Leg} and base={triangle.Base} was drawn");
}
public double Visit(IsoscelesTriangle triangle) => 0.5 * triangle.Base * Math.Sqrt(Math.Pow(triangle.Leg, 2) - 0.25 * Math.Pow(triangle.Base, 2));
public static List <FigSynthProblem> AddShape(Figure outerShape, ShapeType type)
{
List <FigSynthProblem> problems = new List <FigSynthProblem>();
switch (type)
{
case ShapeType.TRIANGLE:
problems.AddRange(Triangle.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.ISOSCELES_TRIANGLE:
problems.AddRange(IsoscelesTriangle.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.RIGHT_TRIANGLE:
problems.AddRange(RightTriangle.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
//case ShapeType.ISO_RIGHT_TRIANGLE:
// problems.AddRange(Triangle.AppendShape(points);
case ShapeType.EQUILATERAL_TRIANGLE:
problems.AddRange(EquilateralTriangle.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.KITE:
problems.AddRange(Kite.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.QUADRILATERAL:
problems.AddRange(Quadrilateral.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.TRAPEZOID:
problems.AddRange(Trapezoid.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.ISO_TRAPEZOID:
problems.AddRange(IsoscelesTrapezoid.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.PARALLELOGRAM:
problems.AddRange(Parallelogram.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.RECTANGLE:
problems.AddRange(Rectangle.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.RHOMBUS:
problems.AddRange(Rhombus.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.SQUARE:
problems.AddRange(Square.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.CIRCLE:
problems.AddRange(Circle.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
case ShapeType.SECTOR:
problems.AddRange(Sector.AppendShape(outerShape, outerShape.GetCompleteSideSegments()));
break;
}
return(problems);
}
//
// Given a set of points, can we construct any shape?
// If we can construct a shape, we then have a resultant mess...
//
public static List <FigSynthProblem> SubtractShape(Figure outerShape, ShapeType type)
{
List <FigSynthProblem> problems = new List <FigSynthProblem>();
List <Connection> conns = new List <Connection>();
List <Point> points = new List <Point>();
try
{
conns = outerShape.MakeAtomicConnections();
points = outerShape.allComposingPoints;
} catch (Exception) { return(problems); }
switch (type)
{
case ShapeType.TRIANGLE:
problems = Triangle.SubtractShape(outerShape, conns, points);
break;
case ShapeType.ISOSCELES_TRIANGLE:
problems = IsoscelesTriangle.SubtractShape(outerShape, conns, points);
break;
case ShapeType.RIGHT_TRIANGLE:
problems = RightTriangle.SubtractShape(outerShape, conns, points);
break;
//case ShapeType.ISO_RIGHT_TRIANGLE:
// problems = Triangle.SubtractShape(outerShape, conns, points);
case ShapeType.EQUILATERAL_TRIANGLE:
problems = EquilateralTriangle.SubtractShape(outerShape, conns, points);
break;
case ShapeType.KITE:
problems = Kite.SubtractShape(outerShape, conns, points);
break;
case ShapeType.QUADRILATERAL:
problems = Quadrilateral.SubtractShape(outerShape, conns, points);
break;
case ShapeType.TRAPEZOID:
problems = Trapezoid.SubtractShape(outerShape, conns, points);
break;
case ShapeType.ISO_TRAPEZOID:
problems = IsoscelesTrapezoid.SubtractShape(outerShape, conns, points);
break;
case ShapeType.PARALLELOGRAM:
problems = Parallelogram.SubtractShape(outerShape, conns, points);
break;
case ShapeType.RECTANGLE:
problems = Rectangle.SubtractShape(outerShape, conns, points);
break;
case ShapeType.RHOMBUS:
problems = Rhombus.SubtractShape(outerShape, conns, points);
break;
case ShapeType.SQUARE:
problems = Square.SubtractShape(outerShape, conns, points);
break;
case ShapeType.CIRCLE:
problems = Circle.SubtractShape(outerShape, conns, points);
break;
case ShapeType.SECTOR:
problems = Sector.SubtractShape(outerShape, conns, points);
break;
}
return(problems);
}
public double Visit(IsoscelesTriangle triangle) => 2 * triangle.Leg + triangle.Base;
public static List <EdgeAggregator> InstantiateTheorem(GroundedClause original, IsoscelesTriangle isoTri)
{
GeometricCongruentAngles newCongSegs = new GeometricCongruentAngles(isoTri.baseAngleOppositeLeg1, isoTri.baseAngleOppositeLeg2);
List <GroundedClause> antecedent = Utilities.MakeList <GroundedClause>(original);
return(Utilities.MakeList <EdgeAggregator>(new EdgeAggregator(antecedent, newCongSegs, annotation)));
}
private static List <EdgeAggregator> InstantiateDefinition(GroundedClause original, IsoscelesTriangle isoTri)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
GeometricCongruentSegments gcs = new GeometricCongruentSegments(isoTri.leg1, isoTri.leg2);
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(original);
newGrounded.Add(new EdgeAggregator(antecedent, gcs, annotation));
return(newGrounded);
}
private void createCurrentShape()
{
switch (drawing)
{
case CurrentDrawing.Ellipse:
Ellipse ellipse = new Ellipse();
ellipse.setFillColor(this.currentFillColor);
ellipse.setBorderColor(this.currentBorderColor);
this.shape = ellipse;
break;
case CurrentDrawing.Circle:
Circle circle = new Circle();
circle.setFillColor(this.currentFillColor);
circle.setBorderColor(this.currentBorderColor);
this.shape = circle;
break;
case CurrentDrawing.Line:
Shape line = new Line();
line.setBorderColor(this.currentBorderColor);
this.shape = line;
break;
case CurrentDrawing.Ray:
Shape ray = new Ray();
ray.setBorderColor(this.currentBorderColor);
this.shape = ray;
break;
case CurrentDrawing.LineSegment:
Shape lineSegment = new LineSegment();
lineSegment.setBorderColor(this.currentBorderColor);
this.shape = lineSegment;
break;
case CurrentDrawing.Poligon:
Poligon poligon = new Poligon();
poligon.setFillColor(this.currentFillColor);
poligon.setBorderColor(this.currentBorderColor);
this.shape = poligon;
break;
case CurrentDrawing.RegularPolygon:
RegularPolygon regularPoligon = new RegularPolygon((int)this.numericUpDown1.Value);
regularPoligon.setFillColor(this.currentFillColor);
regularPoligon.setBorderColor(this.currentBorderColor);
this.shape = regularPoligon;
break;
case CurrentDrawing.RightTriangle:
RightTriangle rightTriangle = new RightTriangle();
rightTriangle.setFillColor(this.currentFillColor);
rightTriangle.setBorderColor(this.currentBorderColor);
this.shape = rightTriangle;
break;
case CurrentDrawing.IsoscelesTriangle:
IsoscelesTriangle isoscelesTriangle = new IsoscelesTriangle();
isoscelesTriangle.setFillColor(this.currentFillColor);
isoscelesTriangle.setBorderColor(this.currentBorderColor);
this.shape = isoscelesTriangle;
break;
case CurrentDrawing.Parallelogram:
Parallelogram parallelogram = new Parallelogram();
parallelogram.setFillColor(this.currentFillColor);
parallelogram.setBorderColor(this.currentBorderColor);
this.shape = parallelogram;
break;
case CurrentDrawing.Rectangle:
Rectangle rectangle = new Rectangle();
rectangle.setFillColor(this.currentFillColor);
rectangle.setBorderColor(this.currentBorderColor);
this.shape = rectangle;
break;
case CurrentDrawing.Rhomb:
Rhomb rhomb = new Rhomb();
rhomb.setFillColor(this.currentFillColor);
rhomb.setBorderColor(this.currentBorderColor);
this.shape = rhomb;
break;
}
}
public AFigure Create(Point first, int n, Color color, Color fillColor, int thickness)
{
IsoscelesTriangle triangle = new IsoscelesTriangle(first, color, fillColor, thickness);
return(triangle);
}
static void Main(string[] args)
{
//7-1 Shapes
Circle shape = new Circle("circle", 4);
Console.WriteLine(shape.GetName());
Console.WriteLine(Math.Round(shape.GetArea(), 2));
IsoscelesTriangle it = new IsoscelesTriangle("triangle", 4, 2);
Console.WriteLine(it.GetName());
Console.WriteLine(it.GetArea());
Console.ReadLine();
//6 Matrix
//const int size = 2;
//const int size2 = 2;
//Matrix m = new Matrix(size);
//Matrix n = new Matrix(size);
//for (int i = 0; i < size; i++)
//{
// for (int j = 0; j < size; j++)
// {
// m[i, j] = rand.Next(10);
// n[i, j] = rand.Next(10);
// }
//}
//m.Print();
//Console.WriteLine();
//n.Print();
//Console.WriteLine();
//m.Multiply(n).Print();
//Console.ReadLine();
//5-2 Polynom
//const int degree1 = 3;
//const int degree2 = 2;
//int[] poly1 = new int[degree1 + 1] { 3, 6, 0, 2 }; //from junior to senior so the index is becoming a degree
//int[] poly2 = new int[degree2 + 1] { 1, 0, 1 };
//Polynom p = new Polynom(degree1, poly1);
//Polynom m = new Polynom(degree2, poly2);
//p.Multiply(2);
//p.Multiply(m);
//Console.WriteLine(p.WritePol());
//Console.ReadLine();
//5-1 Array
//Console.WriteLine("Array");
//int n = 5, low = 11;
//RArray a = new RArray(n, low);
//for (int i = low - 1; i <= low + n; i++)
//{
// try
// {
// a[i] = 1;
// Console.WriteLine("a["+i+"] = "+a[i]);
// }
// catch (IndexOutOfRangeException)
// {
// Console.WriteLine("out of range");
// }
//}
//Console.ReadLine();
//4-2 Arithmetic progression
//Console.WriteLine("Arithmetic progression");
//ArProgression arith = new ArProgression(4, 2);
//Console.WriteLine(arith.GetNItem(10));
//Console.WriteLine(arith.GetSum(10));
//Console.WriteLine(arith.GetAverage(10));
//Console.ReadLine();
//4-1 Quadrate
//Console.WriteLine("Quadrate");
//Quadrate quadr = new Quadrate(4);
//Console.WriteLine(quadr.Area());
//Console.WriteLine(quadr.Perimeter());
//Console.ReadLine();
}
//
// IsoscelesTriangle(A, B, C),
// AngleBisector(Segment(M, C), Angle(A, C, B)),
// Intersection(M, Segment(M, C), Segment(A, B) -> PerpendicularBisector(M, Segment(M, C), Segment(A, B)),
//
// A _____M_____B
// \ | /
// \ | /
// \ | /
// \ | /
// \|/
// C
//
public static List <EdgeAggregator> Instantiate(GroundedClause c)
{
annotation.active = EngineUIBridge.JustificationSwitch.ANGLE_BISECTOR_IS_PERPENDICULAR_BISECTOR_IN_ISOSCELES;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (!(c is Strengthened) && !(c is IsoscelesTriangle) && !(c is AngleBisector) && !(c is Intersection))
{
return(newGrounded);
}
if (c is IsoscelesTriangle)
{
IsoscelesTriangle isoTri = c as IsoscelesTriangle;
foreach (AngleBisector ab in candidateBisectors)
{
foreach (Intersection inter in candidateIntersections)
{
newGrounded.AddRange(GeneratePerpendicularBisector(isoTri, ab, inter));
}
}
candidateIsosceles.Add(isoTri);
}
else if (c is Strengthened)
{
Strengthened streng = c as Strengthened;
// We are not interested if the strengthened clause is not Isosceles (note, this includes equilateral)
if (!(streng.strengthened is IsoscelesTriangle))
{
return(newGrounded);
}
foreach (AngleBisector ab in candidateBisectors)
{
foreach (Intersection inter in candidateIntersections)
{
newGrounded.AddRange(GeneratePerpendicularBisector(streng, ab, inter));
}
}
candidateStrengthened.Add(streng);
}
else if (c is Intersection)
{
Intersection newIntersection = c as Intersection;
foreach (IsoscelesTriangle isoTri in candidateIsosceles)
{
foreach (AngleBisector ab in candidateBisectors)
{
newGrounded.AddRange(GeneratePerpendicularBisector(isoTri, ab, newIntersection));
}
}
candidateIntersections.Add(newIntersection);
}
else if (c is AngleBisector)
{
AngleBisector newAB = c as AngleBisector;
foreach (IsoscelesTriangle isoTri in candidateIsosceles)
{
foreach (Intersection inter in candidateIntersections)
{
newGrounded.AddRange(GeneratePerpendicularBisector(isoTri, newAB, inter));
}
}
candidateBisectors.Add(newAB);
}
return(newGrounded);
}
