Want this question answered?

Q: On a coordinate plane the coordinates of vertices R and T for a polygon are R( and acirc and 136 and 1467 3) and T(3 3). What is the length of Side RT of the polygon?

Write your answer...

Submit

Still have questions?

Related questions

dfv

Coordinates: R is (-6, 2) and T is (1, 2) Length of side RT is 7 units using the distance formula

What do you mean by "arc length of a circle"? If you mean the arc length between two adjacent vertices of the inscribed polygon, then: If the polygon is irregular then the arc length between adjacent vertices of the polygon will vary and it is impossible to calculate and the angle between the radii must be measured from the diagram using a protractor if the angle is not marked. The angle is a fraction of a whole turn (which is 360° or 2π radians) which can be multiplied by the circumference of the circle to find the arc length between the radii: arc_length = 2πradius × angle/angle_of_full_turn → arc_length = 2πradius × angle_in_degrees/360° or arc_length = 2πradius × angle_in_radians/2π = radius × angle_in_radians If there is a regular polygon inscribed in a circle, then there will be a constant angle between the radii of the circle between the adjacent vertices of the polygon and each arc between adjacent vertices will be the same length; assuming you know the radius of the circle, the arc length is thus one number_of_sides_th of the circumference of the circle, namely: arc_length_between_adjacent_vertices_of_inscribed_regular_polygon = 2πradius ÷ number_of_sides

There is not enough information to provide an answer. You need to know the coordinates of three vertices before you can find the coordinates of the fourth. Otherwise, there are alternative solutions using translations, reflections and rotations.

#include<iostream> #include<vector> #include<assert.h> // Typdefs to hide unnecessary implementation detail and remove verbosity. using Coordinates = std::pair<int,int>; using Polygon = std::vector<Coordinates>; // Calculate the area of a given polygon. int area (const Polygon& polygon) { // The given polygon must list all vertices in the correct sequence // either clockwise or anti-clockwise. It does not matter which // vertex begins the sequence, but the last vertex is assumed to // join the first. // Initialise an accumulator. int accumulator = 0; // A polygon with less than 3 vertices is no polygon! if (polygon.size() < 3) return accumulator; // The last vertex is the previous vertex to the first vertex. // We'll deal with this specific pair of vertices first. size_t previous = polygon.size() - 1; // Iterate through all vertices in sequence. for (size_t current=0; current<polygon.size(); ++current) { // The previous and current vertices form an edge. We need to calculate // the area of the imaginary rectangle extending horizontally from this // edge until it meets the Y-axis. This edge may not be vertical so we // also extend in the opposite direction by the same amount. That is, // for vertices {x1, y1} and {x2, y2}, the imaginary rectangle's opposing // corners will be at imaginary vertices {0, y1}, {x1+x2, y2}. The area // of this imaginary rectangle is therefore (x1+x2)*(y1-y2). // Note: the imaginary rectangle's area may be negative but that's OK. // It'll simply be subtracted from the accumulator and that's exactly // what we want. accumulator += (polygon[previous].first + polygon[current].first) * (polygon[previous].second - polygon[current].second); // The current vertex now becomes the previous vertex // in readiness for the next iteration. previous = current; } // Remove the sign (make absolute). accumulator *= (accumulator<0) ? -1 : 1; // At this point the accumulated total is guaranteed to be an even // number (as we'll see). But let's play safe and assert that fact. assert (accumulator % 2 == 0); // Since each imaginary rectangle was exactly double what we needed // (because we extended in both directions), divide the accumulated // total by 2. It's more efficient to do that here, once, rather // than for each individual rectangle. We don't have to worry about // fractions since the accumulator is guaranteed to be even. return accumulator / 2; } // Driver to test the function. int main() { Polygon square; square.push_back (Coordinates (0, 0)); square.push_back (Coordinates (0, 10)); square.push_back (Coordinates (10, 10)); square.push_back (Coordinates (10, 0)); assert (area (square) == 100); std::cout << "Square (10 x 10) has area " << area (square) << std::endl; Polygon triangle; triangle.push_back (Coordinates (0, 0)); triangle.push_back (Coordinates (0, 6)); triangle.push_back (Coordinates (8, 0)); assert (area (triangle) == 24); std::cout << "Right-angled triangle (width 8, height 6) has area " << area (triangle) << std::endl; Polygon irregular; irregular.push_back (Coordinates (0, 0)); irregular.push_back (Coordinates (0, 14)); irregular.push_back (Coordinates (8, 14)); irregular.push_back (Coordinates (8, 4)); irregular.push_back (Coordinates (12, 4)); irregular.push_back (Coordinates (12, 0)); assert (area (irregular) == 128); std::cout << "6-sided irregular polygon has area " << area (irregular) << std::endl; Polygon line; line.push_back (Coordinates (0, 0)); line.push_back (Coordinates (0, 4)); line.push_back (Coordinates (0, 8)); assert (area (line) == 0); std::cout << "3 points on a line of length 8 has area " << area (line) << std::endl; }

An equilateral polygon is a polygon where the length of all the sides of the polygon are the same length.

Just calculate the length of the three sides using the distance formula, then compare which is largest.

A Cartesian coordinate system specifies each point uniquely in a plane by a pair of numerical coordinates, which are the signed distances from the point to two fixed perpendicular directed lines, measured in the same unit of length. Each reference line is called a coordinate axis or just axis of the system.

The primary classification of a polygon is according to the number of sides (or vertices) that it has.If all the sides are of equal length and all the angles are of the same measure then it is a regular polygon.If any of the angles is a reflex angle then it is a concave polygon, otherwise it is convex.

Compare the distance to a known length. Measure. If you know the coordinates of the two dots in an orthogonal coordinate system, use Pythagoras' theorem to find the distance. Say point 1 has coordinate (Ax,By) and point 2 has coordinate (Cx,Dy) then the distance between 1 and 2 is the square root of ((C-A)2 + (D-B)2))

Vertical.

A regular hexagon, one that is both equiangular and equilateral, has an area of 3 times the square root of three times the square of the side length, all divided by 2. Once the side length has been discovered, the area can easily be calculated. However, hexagons with irregular bounds can have their area found, if their vertices are known by coordinate. Multiply each vertex's x coordinate by the y coordinate of the next vertex (looping back around to the first for the sixth), taking the sum of the six numbers found. Then multiply each vertex's y coordinate by the next's x coordinate, once again summing up these six numbers. Finally, subtract the larger of the two by the smaller, and divide this number by 2. This will provide the area in the units of the plot used to find the coordinates.