MathPlotAI Logo MathPlotAI

Connecting Perimeters

Connecting Perimeters
Loading the math board and drawing, please wait…
2018-04-15 19:28
PolygonProbability & StatisticsGeometric ConstructionSlider Animation
This example demonstrates how to construct and analyze the relationship between rectangle perimeters and distributions using GeoGebra. It involves core mathematical concepts such as perimeter calculation, integer applications, probability distributions, division, and logarithms. Key GeoGebra commands and objects used in the construction include Sequence, Polygon, Point, OrthogonalLine, Intersect, Perimeter, Segment, and Text. Suitable for middle school and above students to understand the integration of geometric properties and probability statistics.

GeoGebra Commands & Parameters

  1. Sequence(Sequence[Point[{i, j}], i, ((-length)) / 2, length / 2, 1], j, ((-width)) / 2, width / 2, 1) → list1
  2. Polygon(A, B, C, D) → poly1, a, b, c, d
  3. Point(list1) → E
  4. Point(list1) → F
  5. Point(list1) → G
  6. Point(list1) → H
  7. OrthogonalLine(E, d) → e
  8. OrthogonalLine(E, a) → f
  9. OrthogonalLine(F, a) → g
  10. OrthogonalLine(F, b) → h
  11. OrthogonalLine(H, c) → i
  12. OrthogonalLine(H, d) → j
  13. OrthogonalLine(G, c) → k
  14. OrthogonalLine(G, b) → l
  15. Intersect(c, i) → I
  16. Intersect(j, d) → J
  17. Intersect(b, l) → K
  18. Intersect(g, a) → L
  19. Intersect(h, b) → M
  20. Intersect(k, c) → N
  21. Intersect(f, a) → P
  22. Intersect(e, d) → R
  23. Polygon(H, I, R, J, N, G, K, M, F, L, P, E) → poly2, h_1, e_1, r, j_1, i_1, n, g_1, k_1, m, f_1, l_1, p
  24. Perimeter(poly1) → o
  25. Perimeter(poly2) → q
  26. Sequence(Segment[list1(i, 1), list1(i, length + 1)], i, 1, width + 1) → list2
  27. Sequence(Segment[list1(1, i), list1(width + 1, i)], i, 1, length + 1) → list3
  28. Segment((D * (1 - vertMove)) + (I * vertMove), (J * (1 - vertMove)) + (H * vertMove)) → topLeftVert
  29. Segment((C * (1 - horMove)) + (K * horMove), (N * (1 - horMove)) + (G * horMove)) → topRightHor
  30. Segment((C * (1 - vertMove)) + (N * vertMove), (K * (1 - vertMove)) + (G * vertMove)) → topRightVert
  31. Segment((B * (1 - vertMove)) + (L * vertMove), (M * (1 - vertMove)) + (F * vertMove)) → bottomRightVert
  32. Segment((A * (1 - vertMove)) + (P * vertMove), (R * (1 - vertMove)) + (E * vertMove)) → bottomLeftVert
  33. Segment((D * (1 - horMove)) + (J * horMove), (I * (1 - horMove)) + (H * horMove)) → topLeftHor
  34. Segment((A * (1 - horMove)) + (R * horMove), (P * (1 - horMove)) + (E * horMove)) → bottomLeftHor
  35. Segment((B * (1 - horMove)) + (M * horMove), (L * (1 - horMove)) + (F * horMove)) → bottomRightHor
  36. Segment(D, D + (Min[length, perimeterTimer], 0)) → top
  37. Segment(C, C - (0, ((perimeterTimer > length) * Min[width, perimeterTimer - length]))) → right
  38. Segment(B, B - (((perimeterTimer > length + width) * Min[length, perimeterTimer - width - length]), 0)) → bottom
  39. Segment(A, A + (0, ((perimeterTimer > (2 * length) + width) * Min[width, perimeterTimer - (2 * length) - width]))) → left
  40. Text(d, Midpoint[d] + (-1, 0)) → leftWidthText
  41. Text(a, Midpoint[a] + (0, -1)) → bottomLengthText
  42. Text(Distance[R, L], Midpoint[R, L] - (0, 1)) → text1
  43. Text(Distance[P, M], Midpoint[P, M] - (0, 1)) → text2
  44. Text(Distance[I, K], Midpoint[I, K] + (0, 0.5)) → text3
  45. Text(Distance[J, N], Midpoint[J, N] + (0, 0.5)) → text4
  46. Text(topRightHor, Midpoint[topRightHor] + (0, 1 / 2)) → TRHtext
  47. Text(topLeftHor, Midpoint[topLeftHor] + (0, 1 / 2)) → TLHtext
  48. Text(bottomLeftHor, Midpoint[bottomLeftHor] + (0, -1)) → BLHtext
  49. Text(Distance[P, L], Midpoint[P, L] + (0, -1)) → BMHtext
  50. Text(bottomRightHor, Midpoint[bottomRightHor] + (0, -1)) → BRHtext
  51. Text(Distance[R, D], Midpoint[R, D] + (-0.8, 0)) → text8
  52. Text(Distance[J, P], Midpoint[J, P] + (-0.8, 0)) → text6
  53. Text(Distance[J, R], Midpoint[J, R] + (-0.8, 0)) → text9
  54. Text(Distance[I, N], Midpoint[I, N] + (0, 1 / 2)) → topText
  55. Text(c, Midpoint[c] + (0, 1 / 2)) → topLengthText
  56. Text(Distance[K, M], Midpoint[K, M] + (1 / 2, 0)) → text10
  57. Text(Distance[K, B], Midpoint[K, B] + (1 / 2, 0)) → text13
  58. Text(Distance[M, C], Midpoint[M, C] + (1 / 2, 0)) → text14
  59. Text(b, Midpoint[b] + (1 / 2, 0)) → rightWidthText
  60. Text(Distance[N, G], Midpoint[topRightVert] + (1 / 2, 0)) → text11
  61. Text(Distance[I, H], Midpoint[topLeftVert] + (-0.8, 0)) → text5
  62. Text(Distance[F, L], Midpoint[bottomRightVert] + (1 / 2, 0)) → text12
  63. Text(Distance[E, P], Midpoint[bottomLeftVert] + (-0.8, 0)) → text7
  64. Segment(J, J + (Min[Distance[H, J], perimeterTimer], 0)) → p1
  65. Segment(H, H + (0, ((perimeterTimer > Distance[H, J]) * Min[Distance[I, H], perimeterTimer - Distance[H, J]]))) → p2
  66. Segment(I, I + (Min[Distance[I, N], perimeterTimer - p1 - p2], 0)) → p3
  67. Segment(N, N - (0, Min[Distance[G, N], perimeterTimer - p1 - p2 - p3])) → p4
  68. Segment(G, G + (Min[Distance[G, K], perimeterTimer - p1 - p2 - p3 - p4], 0)) → p5
  69. Segment(K, K + (0, (-Min[Distance[M, K], perimeterTimer - p1 - p2 - p3 - p4 - p5]))) → p6
  70. Segment(M, M + ((-Min[Distance[M, F], perimeterTimer - p1 - p2 - p3 - p4 - p5 - p6]), 0)) → p7
  71. Segment(F, F + (0, (-Min[Distance[F, L], perimeterTimer - p1 - p2 - p3 - p4 - p5 - p6 - p7]))) → p8
  72. Segment(L, L + ((-Min[Distance[L, P], perimeterTimer - p1 - p2 - p3 - p4 - p5 - p6 - p7 - p8]), 0)) → p9
  73. Segment(P, P + (0, Min[Distance[P, E], perimeterTimer - p1 - p2 - p3 - p4 - p5 - p6 - p7 - p8 - p9])) → p10
  74. Segment(E, E + ((-Min[Distance[E, R], perimeterTimer - p1 - p2 - p3 - p4 - p5 - p6 - p7 - p8 - p9 - p10]), 0)) → p11
  75. Segment(R, R + (0, Min[Distance[R, J], perimeterTimer - p1 - p2 - p3 - p4 - p5 - p6 - p7 - p8 - p9 - p10 - p11])) → p12
  76. Text(length, Midpoint[A, B] + (0, -1)) → bottomText
  77. Polygon(O, Q, S, T) → q1, o_1, q_1, s_1, t_1

AI Drawing Prompt Reference

Draw a rectangle filled with a grid of evenly spaced points. Select four interior points, and from each draw perpendicular lines to the rectangle's sides, creating eight intersection points on the boundary. Connect these eight points and the four interior points in order to form an inscribed octagon. Label the perimeters of both the rectangle and the octagon. Inside the rectangle, draw horizontal and vertical segments connecting the grid points. Along the rectangle's sides, show dynamic segments that trace the perimeter, and label the lengths of the octagon's sides.
The prompt above was compiled from the original drawing commands and is for reference only.