/// <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)
{
EquilateralTriangle et = gc as EquilateralTriangle;
if (et != null)
{
givens.Add(et);
}
}
List <Triangle> equiTriangles = new List <Triangle>();
//Populate list with possible choices
foreach (Triangle t in parser.backendParser.implied.polygons[GeometryTutorLib.ConcreteAST.Polygon.TRIANGLE_INDEX])
{
if (isEquilateral(t))
{
EquilateralTriangle et = new EquilateralTriangle(t);
if (!StructurallyContains(givens, et))
{
equiTriangles.Add(et);
}
}
}
options.ItemsSource = null; //Makes sure the box is graphically updated.
options.ItemsSource = equiTriangles;
}
public static void Area()
{
EquilateralTriangle triangle = new EquilateralTriangle(8);
double area = triangle.Area();
Assert.AreEqual(27.71281292, area, Tolerance);
}
public static void Perimeter()
{
EquilateralTriangle triangle = new EquilateralTriangle(8);
double area = triangle.Perimeter();
Assert.AreEqual(24, area, Tolerance);
}
public void PerimeterTest()
{
var expected = 15m;
var triangle = new EquilateralTriangle(5, 10, _CalcTypes.PerimeterCalc);
Assert.AreEqual(triangle.Perimeter, expected);
}
public void AreaTest()
{
var expected = 25.000m;
var triangle = new EquilateralTriangle(5, 10, _CalcTypes.AreaCalc);
Assert.AreEqual(triangle.Area, expected);
}
public static IGeometricShape GetGeometricShape(EGeometricShapes eGeometricShapes, decimal side1, decimal?side2, decimal?base1, decimal?base2, decimal?height)
{
IGeometricShape _iGeometricShape;
switch (eGeometricShapes)
{
case EGeometricShapes.Circle:
_iGeometricShape = new Circle(EGeometricShapes.Circle, side1);
break;
case EGeometricShapes.EquilateralTriangle:
_iGeometricShape = new EquilateralTriangle(EGeometricShapes.EquilateralTriangle, side1);
break;
case EGeometricShapes.Square:
_iGeometricShape = new Square(EGeometricShapes.Square, side1);
break;
case EGeometricShapes.Rectangle:
_iGeometricShape = new Rectangle(EGeometricShapes.Rectangle, side1, side2);
break;
case EGeometricShapes.Trapeze:
_iGeometricShape = new Trapeze(EGeometricShapes.Trapeze, side1, side2, base1, base2, height);
break;
default:
throw new Exception("Unsupported Geometric Form.");
}
return(_iGeometricShape);
}
public BenchmarkCase4()
{
var random = new Random();
shapes = new Shape[Utils.N];
tagShapes = new TagShape[Utils.N];
for (int i = 0; i < shapes.Length; ++i)
{
switch (random.Next(4))
{
case 0:
shapes[i] = new Circle(random.NextDouble());
break;
case 1:
shapes[i] = new EquilateralTriangle(random.NextDouble());
break;
case 2:
shapes[i] = new Square(random.NextDouble());
break;
case 3:
shapes[i] = new Rectangle(random.NextDouble(), random.NextDouble());
break;
}
tagShapes[i] = shapes[i].ToTagShape();
}
}
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();
}
public void Init()
{
ra1 = new RightAngleTriangle("White", 3, 4);
eq1 = new EquilateralTriangle("black", 6);
ra2 = new RightAngleTriangle("White", 7, 4);
eq2 = new EquilateralTriangle("black", 8);
}
public void Create_EquilateralTriangleForInvalidData_TriangleTypeException()
{
// arrange
var sides = ReadTriangleSidesFromTestContext();
// act
var res = new EquilateralTriangle(sides);
// assert
}
static void Main(string[] args)
{
Dictionary <Figure, MyDelegate> figureDictionary = new Dictionary <Figure, MyDelegate>();
Console.WriteLine("Enter A parametr:");
double paramA = double.Parse(Console.ReadLine());
Console.WriteLine("Enter B parametr:");
double paramB = double.Parse(Console.ReadLine());
var square = new Square(paramA);
var circle = new Circle(paramA);
var rectangle = new Rectangle(paramA, paramB);
var triangle = new EquilateralTriangle(paramA);
int i;
Console.Write("Menu:\n1) View Circle info \n2) View Square info \n3) View Rectangle info \n4) View equilateral triangle info \n5) Exit\n");
i = int.Parse(Console.ReadLine());
switch (i)
{
case 1:
MyDelegate circleInfo = delegate { Console.WriteLine(circle.ToString()); };
figureDictionary.Add(Figure.Circle, circleInfo);
figureDictionary[Figure.Circle]();
break;
case 2:
MyDelegate squareInfo = delegate { Console.WriteLine(square.ToString()); };
figureDictionary.Add(Figure.Square, squareInfo);
figureDictionary[Figure.Square]();
break;
case 3:
MyDelegate rectangleInfo = delegate { Console.WriteLine(rectangle.ToString()); };
figureDictionary.Add(Figure.Rectangle, rectangleInfo);
figureDictionary[Figure.Rectangle]();
break;
case 4:
MyDelegate triangleInfo = delegate { Console.WriteLine(triangle.ToString()); };
figureDictionary.Add(Figure.Triangle, triangleInfo);
figureDictionary[Figure.Triangle]();
break;
case 5:
break;
default:
Console.WriteLine("You entered something else...");
break;
}
Console.ReadKey();
}
public void Create_EquilateralTriangleForValidData_IsEquilateralTriangle()
{
// arrange
var sides = ReadTriangleSidesFromTestContext();
// act
var res = new EquilateralTriangle(sides);
// assert
Assert.IsInstanceOfType(res, typeof(EquilateralTriangle));
}
private void AddEquilateralTriangle()
{
Console.WriteLine("Registering Equilateral Triangle\n");
//
var dimension = Extensions.GetSingle("Insert the size dimension: ");
var color = GetColor();
//
var shape = new EquilateralTriangle(color, 3, dimension, dimension, dimension);
Console.WriteLine(shape.ToString());
}
public static void LocalCoordinates()
{
EquilateralTriangle triangle = new EquilateralTriangle(8);
IList <CartesianCoordinate> coordinates = triangle.LocalCoordinates();
Assert.AreEqual(3, coordinates.Count);
Assert.AreEqual(triangleCoordinates[0], coordinates[0]);
Assert.AreEqual(triangleCoordinates[1], coordinates[1]);
Assert.AreEqual(triangleCoordinates[2].X, coordinates[2].X, Tolerance);
Assert.AreEqual(triangleCoordinates[2].Y, coordinates[2].Y, Tolerance);
}
public void AnalyzeMethod_GivenInputs_9_13_14_ResultIs_Scalene_Triangle()
{
// Arrange
String actual = " ";
String expected = "36Scalene triangle";
// Act
actual = EquilateralTriangle.Analyze(9, 13, 14);
// Assert
Assert.AreEqual(expected, actual);
}
public void AnalyzeMethod_GivenInputs_CheckingIfNumbers_ValidToFormTraingle()
{
// Arrange
String actual = " ";
String expected = "Numbers not valid to form traingle";
// Act
actual = EquilateralTriangle.Analyze(1, 2, 3);
// Assert
Assert.AreEqual(expected, actual);
}
public void AnalyzeMethod_GivenTwoInput10_OtherIs8_ResultIs_Isosceles_Triangle()
{
// Arrange
String actual = " ";
String expected = "28Isosceles triangle";
// Act
actual = EquilateralTriangle.Analyze(10, 10, 8);
// Assert
Assert.AreEqual(expected, actual);
}
public void AnalyzeMethod_GivenAllInputs_5_Results_Equilateral_Traingle()
{
//Arrange
String actual = "";
String expected = "15Equilateral triangle";
//Act
actual = EquilateralTriangle.Analyze(5, 5, 5);
//Assert
Assert.AreEqual(expected, actual);
}
public void SetUp() => Schedule(() =>
{
Child = beatDivisorControl = new BeatDivisorControl(bindableBeatDivisor = new BindableBeatDivisor(16))
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Size = new Vector2(90, 90)
};
tickSliderBar = beatDivisorControl.ChildrenOfType <SliderBar <int> >().Single();
tickMarkerHead = tickSliderBar.ChildrenOfType <EquilateralTriangle>().Single();
});
public void Init()
{
sq1 = new Square("Blue", 4);
rec1 = new Rectangle("Red", 4, 3);
ra1 = new RightAngleTriangle("White", 3, 4);
eq1 = new EquilateralTriangle("black", 6);
sq2 = new Square("Blue", 6);
rec2 = new Rectangle("Red", 5, 4);
ra2 = new RightAngleTriangle("White", 7, 4);
eq2 = new EquilateralTriangle("black", 8);
}
public static decimal CalculateVolume(decimal height, decimal width, decimal length, _3DBases b)
{
switch (b)
{
case _3DBases.Square:
return(Math.Round(Square.CalculateArea(height) * length, 3));
case _3DBases.Triangle:
return(Math.Round(EquilateralTriangle.CalculateArea(height, width) * length, 3));
default:
return(123456m);
}
}
public static decimal CalculateArea(decimal height, decimal width, decimal length, _3DBases b)
{
switch (b)
{
case _3DBases.Square:
return((Square.CalculateArea(height) * 2) + (Rectangle.CalculateArea(height, length) * 4));
case _3DBases.Triangle:
return((EquilateralTriangle.CalculateArea(height, width) * 2) + (Rectangle.CalculateArea(width, length) * 3));
default:
return(123456m);
}
}
public static decimal CalculateVolume(decimal length, decimal width, decimal height, _3DBases b)
{
switch (b)
{
case _3DBases.Square:
return((1m / 3m) * Square.CalculateArea(length) * height);
case _3DBases.Triangle:
return((1m / 3m) * EquilateralTriangle.CalculateArea(length, width) * height);
default:
return(123456m);
}
}
public static decimal CalculateArea(decimal length, decimal width, decimal height, _3DBases b)
{
switch (b)
{
case _3DBases.Square:
return(Square.CalculateArea(length) + (0.5m * Square.CalculatePerimeter(length) * Right_AngledTriangle.CalculateHypotenuse(height, 0.5m * length)));
case _3DBases.Triangle:
return(EquilateralTriangle.CalculateArea(length, width) + (0.5m * EquilateralTriangle.CalculatePerimeter(width) * Right_AngledTriangle.CalculateHypotenuse(width, height)));
default:
return(123456m);
}
}
public void EquilateralTriangleTests(string color, float s1, float expArea, float expPer)
{
eq1 = new EquilateralTriangle(color, s1);
//float area = 15.59f;
//float perimeter = 18;
Assert.AreEqual(Math.Round(expArea, 2), Math.Round(eq1.GetArea(), 2));
Assert.AreEqual(Math.Round(expPer, 2), Math.Round(eq1.GetPerimeter(), 2));
//area = 27.71f;
//perimeter = 24;
//Assert.AreEqual(Math.Round(area, 2), Math.Round(eq2.GetArea(), 2));
//Assert.AreEqual(Math.Round(perimeter, 2), Math.Round(eq2.GetPerimeter(), 2));
}
public static void Main()
{
double r = 4.0;
Geometry a = new Geometry(r);
Geometry c = new Circle(r);
Geometry s = new Sphere(r);
Geometry et = new EquilateralTriangle(r);
Console.WriteLine("r={0}，相应地", r);
Console.WriteLine("正方形的面积为:{0}", a.Area());
Console.WriteLine("圆的面积为:{0}", c.Area());
Console.WriteLine("球体的表面积为:{0}", s.Area());
Console.WriteLine("等边三角形的面积为:{0}", et.Area());
}
public void EquilateralTriangleTest()
{
EquilateralTriangle triangle = new EquilateralTriangle();
triangle.SideLength = 10;
double areaExpected = 43.30;
double area = Math.Round(triangle.Area(), 2);
Assert.Equal(areaExpected, area);
double perimeterExpected = 30;
double perimeter = triangle.Perimeter();
Assert.Equal(perimeterExpected, perimeter);
}
public static void Initialization_with_Apex_Coordinate_Creates_Shape()
{
EquilateralTriangle triangle = new EquilateralTriangle(triangleCoordinates[2]);
Assert.AreEqual(GeometryLibrary.ZeroTolerance, triangle.Tolerance);
Assert.AreEqual(3, triangle.Points.Count);
Assert.AreEqual(triangleCoordinates[0], triangle.SideA.I);
Assert.AreEqual(triangleCoordinates[1], triangle.SideA.J);
Assert.AreEqual(triangleCoordinates[1], triangle.SideB.I);
Assert.AreEqual(triangleCoordinates[2].X, triangle.SideB.J.X, Tolerance);
Assert.AreEqual(triangleCoordinates[2].Y, triangle.SideB.J.Y, Tolerance);
Assert.AreEqual(triangleCoordinates[2].X, triangle.SideC.I.X, Tolerance);
Assert.AreEqual(triangleCoordinates[2].Y, triangle.SideC.I.Y, Tolerance);
Assert.AreEqual(triangleCoordinates[0], triangle.SideC.J);
Assert.AreEqual(3, triangle.Sides.Count);
Assert.AreEqual(8, triangle.SideA.Length(), Tolerance);
Assert.AreEqual(8, triangle.SideB.Length(), Tolerance);
Assert.AreEqual(8, triangle.SideC.Length(), Tolerance);
Assert.AreEqual(3, triangle.Angles.Count);
Assert.AreEqual(60, triangle.AngleA.Degrees, Tolerance);
Assert.AreEqual(60, triangle.AngleB.Degrees, Tolerance);
Assert.AreEqual(60, triangle.AngleC.Degrees, Tolerance);
Assert.AreEqual(6.92820, triangle.h, Tolerance);
Assert.AreEqual(4, triangle.Centroid.X, Tolerance);
Assert.AreEqual(2.309401077, triangle.Centroid.Y, Tolerance);
Assert.AreEqual(4, triangle.OrthoCenter.X, Tolerance);
Assert.AreEqual(2.309401077, triangle.OrthoCenter.Y, Tolerance);
Assert.AreEqual(4.618802154, triangle.CircumRadius, Tolerance);
Assert.AreEqual(4, triangle.CircumCenter.X, Tolerance);
Assert.AreEqual(2.309401077, triangle.CircumCenter.Y, Tolerance);
Assert.AreEqual(2.309401077, triangle.InRadius, Tolerance);
Assert.AreEqual(4, triangle.InCenter.X, Tolerance);
Assert.AreEqual(2.309401077, triangle.InCenter.Y, Tolerance);
}
//
// Generate the three pairs of congruent segments.
//
private static List <EdgeAggregator> InstantiateFromDefinition(EquilateralTriangle tri, GroundedClause original)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// Hypergraph
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(original);
//
// Create the 3 sets of congruent segments.
//
for (int s = 0; s < tri.orderedSides.Count; s++)
{
GeometricCongruentSegments gcs = new GeometricCongruentSegments(tri.orderedSides[s], tri.orderedSides[(s + 1) % tri.orderedSides.Count]);
newGrounded.Add(new EdgeAggregator(antecedent, gcs, annotation));
}
//
// Create the 3 congruent angles.
//
for (int a = 0; a < tri.angles.Count; a++)
{
GeometricCongruentAngles gcas = new GeometricCongruentAngles(tri.angles[a], tri.angles[(a + 1) % tri.angles.Count]);
newGrounded.Add(new EdgeAggregator(antecedent, gcas, annotation));
}
//
// Create the 3 equations for the measure of each angle being 60 degrees.
//
for (int a = 0; a < tri.angles.Count; a++)
{
GeometricAngleEquation gae = new GeometricAngleEquation(tri.angles[a], new NumericValue(60));
newGrounded.Add(new EdgeAggregator(antecedent, gae, annotation));
}
return(newGrounded);
}
//
// EquilateralTriangle(A, B, C) -> Equation(m \angle ABC = 60),
// Equation(m \angle BCA = 60),
// Equation(m \angle CAB = 60)
//
public static List <EdgeAggregator> Instantiate(GroundedClause c)
{
annotation.active = EngineUIBridge.JustificationSwitch.EQUILATERAL_TRIANGLE_HAS_SIXTY_DEGREE_ANGLES;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (!(c is EquilateralTriangle) && !(c is Strengthened))
{
return(newGrounded);
}
EquilateralTriangle eqTri = c as EquilateralTriangle;
if (c is Strengthened)
{
eqTri = (c as Strengthened).strengthened as EquilateralTriangle;
}
if (eqTri == null)
{
return(newGrounded);
}
// EquilateralTriangle(A, B, C) ->
List <GroundedClause> antecedent = Utilities.MakeList <GroundedClause>(c);
// -> Equation(m \angle ABC = 60),
// Equation(m \angle BCA = 60),
// Equation(m \angle CAB = 60)
GeometricAngleEquation eq1 = new GeometricAngleEquation(eqTri.AngleA, new NumericValue(60));
GeometricAngleEquation eq2 = new GeometricAngleEquation(eqTri.AngleB, new NumericValue(60));
GeometricAngleEquation eq3 = new GeometricAngleEquation(eqTri.AngleC, new NumericValue(60));
newGrounded.Add(new EdgeAggregator(antecedent, eq1, annotation));
newGrounded.Add(new EdgeAggregator(antecedent, eq2, annotation));
newGrounded.Add(new EdgeAggregator(antecedent, eq3, annotation));
return(newGrounded);
}
