public void TriangleTest()
{
var triangle = new Triangle(5, 6);
Assert.AreEqual(5, triangle.SideA);
Assert.AreEqual(6, triangle.SideB);
Assert.AreEqual(15, triangle.Area);
var triangle2 = new RightTriangle(5, 6);
Assert.AreEqual(triangle, triangle2);
Assert.AreEqual(triangle.Perimeter, triangle2.Perimeter);
var triangle3 = new Triangle(sideB: 4, sideC: 5, angleC: 90);
Assert.AreEqual(triangle3.Area, 6);
Assert.AreEqual(12, triangle3.Perimeter);
var triangle4 = new Triangle(sideB: 3, sideC: 3, angleC: 60);
Assert.AreEqual(9, triangle4.Perimeter);
/*
* try
* {
* Triangle wrongTriangle = new Triangle(1,6,10);
* Assert.Fail("This triangle should've thrown an exception!");
* }
* catch (Mathos.Exceptions.InvalidTriangleException)
* {
* }
*/
}
public void RightTriangle_CalculateArea_With_Sides_3_4_5_Is_6()
{
var rightTriangle = new RightTriangle(3, 4, 5);
var area = rightTriangle.CalculateArea();
Assert.AreEqual(6, area, "Разные значения");
}
public static void Area()
{
RightTriangle triangle = new RightTriangle(4, 6);
double area = triangle.Area();
Assert.AreEqual(12, area, Tolerance);
}
public void RightTriangleAreaCalculationCorrect()
{
var figure = new RightTriangle(3, 6);
var result = figure.Area;
Assert.Equal(9, result);
}
public void InputSidesOutputArea(double leg1, double leg2, double hypotenuse, double expected)
{
var triangle = new RightTriangle(leg1, leg2, hypotenuse);
var actual = triangle.GetArea();
Assert.AreEqual(expected, actual, 1E-4);
}
private Shapes GetRandomShape()
{
Shapes shape = null;
switch (Random.Range(1, 5))
{
case 1:
shape = new Square(Random.Range(1f, 10f), GetRandomColor());
break;
case 2:
shape = new Circle(Random.Range(1f, 10f), GetRandomColor());
break;
case 3:
shape = new RightTriangle(Random.Range(1f, 10f), Random.Range(1f, 10f), GetRandomColor());
break;
case 4:
shape = new Trapeze(Random.Range(1f, 10f), Random.Range(1f, 10f), Random.Range(1f, 5f),
GetRandomColor());
break;
default:
Debug.Log("Shape is not generated");
break;
}
return(shape);
}
public void NotValidArgumentsInConstructor()
{
var rect = new RightTriangle(0f, 7f);
rect = new RightTriangle(3f, 0f);
rect = new RightTriangle(-3f, 7f);
rect = new RightTriangle(3f, -7f);
}
public void CalculateSquare(double cathetus1, double cathetus2, double expectedSquare)
{
var triangle = new RightTriangle(cathetus1, cathetus2);
var square = triangle.Square();
Assert.Equal(expectedSquare, square);
}
public string Post([FromBody] string jsonTriangle)
{
RightTriangle rt = new RightTriangle();
string result = rt.RightTriangleToCoordinate(jsonTriangle);
return(result);
}
public void TestCreateRightTrinagle()
{
double a = 3;
double b = 4;
double badSide = 6;
Figure triangle = new RightTriangle(a, b, badSide);
}
public void TestRightTriangle(int x1, int y1, int x2, int y2, int[] ExPoints)
{
RightTriangle Actual = new RightTriangle();
bool ActualPoint = Actual.CheckForMatches(x1, y1, x2, y2, 0, ExPoints);
bool Expected = true;
Assert.AreEqual(Expected, ActualPoint);
}
public void RightAreaTest()
{
RightTriangle triangle = new RightTriangle(3, 4, 5);
double area = triangle.Area;
Assert.AreEqual(6, area, "Right Area");
}
public static List <EdgeAggregator> InstantiateRight(RightTriangle rt, Altitude altitude, GroundedClause original)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
// The altitude must connect the vertex defining the right angle and the opposite side.
if (!altitude.segment.HasPoint(rt.rightAngle.GetVertex()))
{
return(newGrounded);
}
// The other point of the altitude must lie on the opposite side of the triangle
Point altPointOppRightAngle = altitude.segment.OtherPoint(rt.rightAngle.GetVertex());
Segment oppositeSide = rt.GetOppositeSide(rt.rightAngle);
if (!Segment.Between(altPointOppRightAngle, oppositeSide.Point1, oppositeSide.Point2))
{
return(newGrounded);
}
//
// Find the two smaller right triangles in the candidate list (which should be in the list at this point)
//
RightTriangle first = null;
RightTriangle second = null;
foreach (RightTriangle smallerRT in candRightTriangles)
{
if (smallerRT.IsDefinedBy(rt, altitude))
{
if (first == null)
{
first = smallerRT;
}
else
{
second = smallerRT;
break;
}
}
}
// CTA: We did not check to see points aligned, but these are the original triangles from the figure
GeometricSimilarTriangles gsts1 = new GeometricSimilarTriangles(rt, first);
GeometricSimilarTriangles gsts2 = new GeometricSimilarTriangles(rt, second);
GeometricSimilarTriangles gsts3 = new GeometricSimilarTriangles(first, second);
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(original);
antecedent.Add(altitude);
newGrounded.Add(new EdgeAggregator(antecedent, gsts1, annotation));
newGrounded.Add(new EdgeAggregator(antecedent, gsts2, annotation));
newGrounded.Add(new EdgeAggregator(antecedent, gsts3, annotation));
return(newGrounded);
}
public void InvertedRightTriangleShouldBeInvalid()
{
var myTriangle = new RightTriangle(new VertexPoint(10, 10), new VertexPoint(10, 0), new VertexPoint(0, 10));
Assert.IsFalse(myTriangle.IsValid);
myTriangle = new RightTriangle(new VertexPoint(0, 0), new VertexPoint(0, 10), new VertexPoint(10, 0));
Assert.IsFalse(myTriangle.IsValid);
}
public void InvalidPositionShouldReturnNoPosition()
{
var myImage = new Image(60, 60, 10, 10);
var myTriangle = new RightTriangle(new VertexPoint(60, 10), new VertexPoint(60, 0), new VertexPoint(70, 10));
Assert.IsTrue(myTriangle.IsValid);
Assert.IsNull(myImage.CalculateMatrixPosition(myTriangle).Row);
Assert.AreEqual(0, myImage.CalculateMatrixPosition(myTriangle).Column);
}
public void TestAreaCalculate()
{
var triangle1 = new RightTriangle(3, 4);
Assert.AreEqual(triangle1.Area, 6d);
var triangle2 = new RightTriangle(20, 100);
Assert.AreEqual(triangle2.Area, 1000d);
}
public void TestIsRight()
{
var rightTriangle1 = new RightTriangle(1, 2);
Assert.IsTrue(rightTriangle1.IsRight);
var rightTriangle2 = new RightTriangle(22, 45);
Assert.IsTrue(rightTriangle2.IsRight);
}
public void RightTriangle_PointConstructorTest()
{
// Build right triangle with line segments
Point rt_cornerOne = new Point(Point.MakePointWithInches(2, 1));
Point rt_cornerTwo = new Point(Point.MakePointWithInches(2, 4));
Point rt_cornerThree = new Point(Point.MakePointWithInches(4, 1));
List<Point> rt_sides = new List<Point>() { rt_cornerOne, rt_cornerTwo, rt_cornerThree };
RightTriangle rt = new RightTriangle(rt_sides);
}
//
// T
// |\
// | \
// | \ N <-----------Right Angle
// | / \
// |/___\
// U S
//
// Altitude(Segment(U, N), Triangle(S, U, T)), RightTriangle(S, U, T) -> Similar(RightTriangle(S, U, T), RightTriangle(S, N, U)),
// Similar(RightTriangle(S, N, U), RightTriangle(U, N, T))
// Similar(RightTriangle(U, N, T), RightTriangle(S, U, T))
//
public static List <EdgeAggregator> Instantiate(GroundedClause c)
{
annotation.active = EngineUIBridge.JustificationSwitch.ALTITUDE_OF_RIGHT_TRIANGLES_IMPLIES_SIMILAR;
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (!(c is Altitude) && !(c is RightTriangle) && !(c is Strengthened))
{
return(newGrounded);
}
if (c is Strengthened)
{
Strengthened streng = c as Strengthened;
if (!(streng.strengthened is RightTriangle))
{
return(newGrounded);
}
foreach (Altitude altitude in candidateAltitudes)
{
newGrounded.AddRange(InstantiateRight(streng.strengthened as RightTriangle, altitude, streng));
}
candidateStrengthened.Add(streng);
}
else if (c is RightTriangle)
{
RightTriangle rt = c as RightTriangle;
foreach (Altitude altitude in candidateAltitudes)
{
newGrounded.AddRange(InstantiateRight(rt, altitude, rt));
}
candRightTriangles.Add(rt);
}
else if (c is Altitude)
{
Altitude altitude = c as Altitude;
foreach (RightTriangle rt in candRightTriangles)
{
newGrounded.AddRange(InstantiateRight(rt, altitude, rt));
}
foreach (Strengthened stren in candidateStrengthened)
{
newGrounded.AddRange(InstantiateRight(stren.strengthened as RightTriangle, altitude, stren));
}
candidateAltitudes.Add(altitude);
}
return(newGrounded);
}
static void Main(string[] args)
{
Figure triangle = new RightTriangle(7, 4);
Figure circle = new Circle(5);
Console.WriteLine($"S прямоугольного треугольника ABC = {triangle.GetArea()}");
Console.WriteLine($"S окружности = {circle.GetArea()}");
Console.ReadKey();
}
// END CUT HERE
// BEGIN CUT HERE
public static void Main()
{
RightTriangle ___test = new RightTriangle();
___test.run_test(-1);
try {
} catch(Exception e) {
//Console.WriteLine(e.StackTrace);
Console.WriteLine(e.ToString());
}
}
public void RightTriangle_HypotenuseTest()
{
LineSegment rt_sideOne = new LineSegment(Point.MakePointWithInches(2, 1), Point.MakePointWithInches(4, 1));
LineSegment rt_sideTwo = new LineSegment(Point.MakePointWithInches(2, 1), Point.MakePointWithInches(2, 4));
LineSegment rt_sideThree = new LineSegment(Point.MakePointWithInches(2, 4), Point.MakePointWithInches(4, 1));
List<LineSegment> rt_sides = new List<LineSegment>() { rt_sideOne, rt_sideTwo, rt_sideThree };
RightTriangle rt = new RightTriangle(rt_sides);
(rt.Hypotenuse == rt_sideThree).Should().BeTrue();
}
public void RightTriangle_AreaTest()
{
LineSegment rt_sideOne = new LineSegment(Point.MakePointWithInches(2, 1), Point.MakePointWithInches(4, 1));
LineSegment rt_sideTwo = new LineSegment(Point.MakePointWithInches(2, 1), Point.MakePointWithInches(2, 4));
LineSegment rt_sideThree = new LineSegment(Point.MakePointWithInches(2, 4), Point.MakePointWithInches(4, 1));
List<LineSegment> rt_sides = new List<LineSegment>() { rt_sideOne, rt_sideTwo, rt_sideThree };
RightTriangle rt = new RightTriangle(rt_sides);
(rt.Area == new Area(new SquareInch(), 3)).Should().BeTrue();
}
static void Main(string[] args)
{
IFigure circle = new Circle(3);
IFigure triangle = new RightTriangle(4, 6);
IFigure triangle2 = new Triangle(4, 6, 5);
Console.WriteLine(circle.GetArea());
Console.WriteLine(triangle.GetArea());
Console.WriteLine(triangle2.GetArea());
Console.ReadKey();
}
public void TriangleTest()
{
Triangle t = new Triangle(5, 7, 9);
Assert.AreEqual(t.Perimetr(), 21);
RightTriangle rt = new RightTriangle(3, 4, 5);
Assert.AreEqual(rt.Perimetr(), 12);
Assert.AreEqual(rt.Area(), 6);
}
// END CUT HERE
// BEGIN CUT HERE
public static void Main()
{
RightTriangle ___test = new RightTriangle();
___test.run_test(-1);
try {
} catch (Exception e) {
//Console.WriteLine(e.StackTrace);
Console.WriteLine(e.ToString());
}
}
public static void LocalCoordinates()
{
RightTriangle triangle = new RightTriangle(4, 6);
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 RightTriangleAreaCorrectCalculationTest()
{
// Arrange
IFigure figure = new RightTriangle(3, 4);
// Act
double area = figure.GetFigureArea();
// Assert
Assert.Equal(6, area);
}
public void RightTriangle_LineSegmentConstructorTest()
{
// Build right triangle with line segments
LineSegment rt_sideOne = new LineSegment(Point.MakePointWithInches(2, 1), Point.MakePointWithInches(4, 1));
LineSegment rt_sideTwo = new LineSegment(Point.MakePointWithInches(2, 1), Point.MakePointWithInches(2, 4));
LineSegment rt_sideThree = new LineSegment(Point.MakePointWithInches(2, 4), Point.MakePointWithInches(4, 1));
List <LineSegment> rt_sides = new List <LineSegment>()
{
rt_sideOne, rt_sideTwo, rt_sideThree
};
RightTriangle rt = new RightTriangle(rt_sides);
}
//private ArrayList dArr = new ArrayList();
//private ArrayList angArr = new ArrayList(); //angle change
public Rob()
{
realAngle = 0;
topLeft = new PointF((float)200.0,(float)200.0);
prevTL = topLeft;
prevAngle = realAngle;
width = (float)36.0;
moveEnabled = false;
/* topLeft = new Point(x, y);
topRight = new Point(x, y+width);
bottomLeft = new Point(x+width, y);
bottomRight = new Point(x+width, y+width);
realAngle = 0;
picAngle = 0;*/
//text = "R";
//this.BackColor = System.Drawing.Color.Green;
hwidth = (float)(width / 2.0);
centre.X = (float)(topLeft.X + hwidth);
centre.Y = (float)(topLeft.Y + hwidth);
triPt.X = (float)(topLeft.X);
triPt.Y = (float)(topLeft.Y);
vector = new RightTriangle(triPt, realAngle, 5);
xOff = vector.xSide;
yOff = vector.ySide;
x = topLeft.X;
y = topLeft.Y;
topRight.X = (float)(centre.X + hwidth);
topRight.Y = (float)(centre.Y - hwidth);
bottomLeft.X = (float)(centre.X - hwidth);
bottomLeft.Y = (float)(centre.Y + hwidth);
bottomRight.X = (float)(centre.X + hwidth);
bottomRight.Y = (float)(centre.Y + hwidth);
//r = new Rectangle(x, y, width, width);
myBrush = new SolidBrush(System.Drawing.Color.Green);
//font = new Font(new System.Drawing.FontFamily("Consolas"),20,FontStyle.Bold);
updateArr();
}
