MathPlotAI Logo MathPlotAI

Partitioning Areas of Rectangles with Mixed Number Side Lengths

Partitioning Areas of Rectangles with Mixed Number Side Lengths
Loading the math board and drawing, please wait…
2023-05-23 19:24
Coordinate GeometryGeometric ConstructionSlider Animation
This example calculates the areas of rectangles with fractional side lengths by partitioning and counting unit areas. It explores the relationship between the total number of square units in a rectangle and its length and width, suitable for 4-5 grade students. GeoGebra commands used include slider animation, partitioning, maximum, polygon, sequence, etc.

GeoGebra Commands & Parameters

  1. Shuffle({{2, 2}, {2, 4}, {4, 2}, {2, 6}, {6, 2}, {3, 3}, {3, 6}, {6, 3}, {4, 4}, {5, 5}}) → m1, {{6, 2}, {2, 6}, {2, 4}, {3, 3}, {6, 3}, {5, 5}, {3, 6}, {4, 4}, {4, 2}, {2, 2}}
  2. Shuffle(Sequence[maxInt1]) → integers1, {1, 3, 2}
  3. Shuffle(Sequence[maxInt2]) → integers2, {1, 5, 6, 4, 3, 2}
  4. Element(m1, Mod[example, Length[m1]] + 1) → Denominators
  5. Shuffle(Sequence[den1 - 1]) → numerators1, {1, 3, 4, 2, 5}
  6. Shuffle(Sequence[den2 - 1]) → numerators2, {1}
  7. LCM(Denominators) → comonDen
  8. Max(KeepIf[IsInteger[comonDen^(2) / kk], kk, Sequence[(num1 * comonDen / den1)]]) → hRecBelow
  9. Max(KeepIf[IsInteger[comonDen^(2) / kk], kk, Sequence[(num2 * comonDen / den2)]]) → wRecSide
  10. Polygon({(0, maxInt1 + 1 - int1), (0, maxInt1 + 1 - int1 - (hRecBelow * 1 / comonDen)), (wRecBelow / comonDen, maxInt1 + 1 - int1 - (hRecBelow * 1 / comonDen)), (wRecBelow / comonDen, maxInt1 + 1 - int1)}) → RecBelow
  11. Sequence(Sequence[Translate[RecBelow, Vector[((ii * wRecBelow / comonDen), (jj * ((-hRecBelow)) / comonDen))]], ii, 0, floor((int2 * comonDen / wRecBelow)) - 1], jj, 0, numberOfRowsBelow - 1) → rectanglesBelowTarget, {{}}
  12. Length(Flatten[rectanglesBelowTarget]) → numOfRecBelow
  13. Polygon({(int2, maxInt1 + 1), (int2, maxInt1 + 1 - hRecSide / comonDen), (int2 + wRecSide / comonDen, maxInt1 + 1 - hRecSide / comonDen), (int2 + wRecSide / comonDen, maxInt1 + 1)}) → RecSide
  14. Sequence(Sequence[Translate[RecSide, Vector[((jj * wRecSide / comonDen), (ii * ((-hRecSide)) / comonDen))]], ii, 0, floor((int1 * comonDen / hRecSide)) - 1], jj, 0, numberOfColumnsSide - 1) → rectanglesSideTarget, {{}}
  15. Length(Flatten[rectanglesSideTarget]) → numOfRecSide
  16. Polygon({(0, Max[integers1] + 1), (0, Max[integers1] + 1 - int1 - num1 / den1), (int2 + num2 / den2, Max[integers1] + 1 - int1 - num1 / den1), (int2 + num2 / den2, Max[integers1] + 1)}) → q1
  17. Mod(remainder, comonDen^(2)) → lastSquares
  18. Translate((int2, maxInt1 + 1), Vector[((numberOfColumnsSide * wRecSide / comonDen), (floor((int1 * comonDen / hRecSide)) * ((-hRecSide)) / comonDen))]) → EndPointLZone5
  19. Flatten(Sequence[Sequence[Polygon[EndPointLZone5 + (ii / comonDen, jj / comonDen), EndPointLZone5 + ((ii + 1) / comonDen, jj / comonDen), 4], ii, 0, ((x(EndPointRZone5) - x(EndPointLZone5)) * comonDen) - 1], jj, 0, ((y(EndPointRZone5) - y(EndPointLZone5)) * comonDen) - 1]) → Zone5
  20. Flatten(Sequence[Sequence[Polygon[EndPointLZone4 + (ii / comonDen, jj / comonDen), EndPointLZone4 + ((ii + 1) / comonDen, jj / comonDen), 4], ii, 0, ((x(EndPointRZone4) - x(EndPointLZone4)) * comonDen) - 1], jj, 0, ((y(EndPointRZone4) - y(EndPointLZone4)) * comonDen) - 1]) → Zone4
  21. Flatten(Sequence[Sequence[Polygon[EndPointLZone3 + (ii / comonDen, jj / comonDen), EndPointLZone3 + ((ii + 1) / comonDen, jj / comonDen), 4], ii, 0, ((x(EndPointRZone3) - x(EndPointLZone3)) * comonDen) - 1], jj, 0, ((y(EndPointRZone3) - y(EndPointLZone3)) * comonDen) - 1]) → Zone3
  22. Translate((0, maxInt1 + 1 - int1), Vector[((floor((int2 * comonDen / wRecBelow)) * wRecBelow / comonDen), (numberOfRowsBelow * ((-hRecBelow)) / comonDen))]) → EndPointRZone1
  23. Flatten(Sequence[Sequence[Polygon[EndPointLZone2 + (ii / comonDen, jj / comonDen), EndPointLZone2 + ((ii + 1) / comonDen, jj / comonDen), 4], ii, 0, ((x(EndPointRZone2) - x(EndPointLZone2)) * comonDen) - 1], jj, 0, ((y(EndPointRZone2) - y(EndPointLZone2)) * comonDen) - 1]) → Zone2
  24. Flatten(Sequence[Sequence[Polygon[EndPointLZone1 + (ii / comonDen, jj / comonDen), EndPointLZone1 + ((ii + 1) / comonDen, jj / comonDen), 4], ii, 0, (x(EndPointRZone1) * comonDen) - 1], jj, 0, ((y(EndPointRZone1) - y(EndPointLZone1)) * comonDen) - 1]) → Zone1
  25. Join({Zone1, Zone2, Zone3, Zone4, Zone5}) → ZoneAll
  26. Corner(5) → AppSize
  27. Polygon({CornerUS, CornerUS - (0, 1), CornerUS + (1, -1), CornerUS + (1, 0)}) → unitSquare
  28. Flatten(Sequence[Sequence[(ii, maxInt1 + 1 - jj), jj, 0, int1 - 1], ii, 0, int2 - 1]) → TargetPointsUS
  29. Zip(Translate[unitSquare, Vector[(Min[Max[sliderUS - kk, 0], 1] * Vector[CornerUS, PP])]], PP, TargetPointsUS, kk, Sequence[0, (int1 * int2) - 1]) → MovableUS
  30. Translate(RecBelow, Vector[(0, maxInt1 + 1 - int1), CornerURB]) → RecBelow'
  31. Translate(RecSide, Vector[(int2, maxInt1 + 1), CornerURS]) → RecSide'
  32. Point(Circle[(0, 5.5), int2 + num2 / den2]) → A
  33. Segment((0, maxInt1 + 1.3), (int2 + num2 / den2, maxInt1 + 1.3)) → segmenAbove
  34. Segment((-0.3, maxInt1 + 1), (-0.3, maxInt1 + 1 - int1 - num1 / den1)) → segmentSide
  35. Midpoint(segmenAbove) → LabelSegAbovePos
  36. Midpoint(segmentSide) → LablelSegmentSidePos
  37. Sequence(Segment[(0, ii), (maxInt2 + 1, ii)], ii, 0, maxInt1 + 1) → GridMH
  38. Sequence(Segment[(ii, 0), (ii, maxInt1 + 1)], ii, 0, maxInt2 + 1) → GridMV
  39. Sequence(Segment[(0, ii), (maxInt2 + 1, ii)], ii, 0, maxInt1 + 1, 1 / comonDen) → GridmH
  40. Sequence(Segment[(ii, 0), (ii, 1 + maxInt1)], ii, 0, maxInt2 + 1, 1 / comonDen) → GridmV
  41. Flatten(Sequence[Sequence[Translate[(int2, maxInt1 + 1), Vector[((jj * wRecSide / comonDen), (ii * ((-hRecSide)) / comonDen))]], ii, 0, floor((int1 * comonDen / hRecSide)) - 1], jj, 0, numberOfColumnsSide - 1]) → TargetPointsRecS
  42. Zip(Translate[RecSide', Vector[(Min[Max[sliderRS - kk, 0], 1] * Vector[CornerURS, PP])]], PP, TargetPointsRecS, kk, Sequence[0, numOfRecSide]) → rectanglesSideMovable
  43. Flatten(Sequence[Sequence[Translate[(0, maxInt1 + 1 - int1), Vector[((ii * wRecBelow / comonDen), (jj * ((-hRecBelow)) / comonDen))]], ii, 0, floor((int2 * comonDen / wRecBelow)) - 1], jj, 0, numberOfRowsBelow - 1]) → TargetPointsRecB
  44. Zip(Translate[RecBelow', Vector[(Min[Max[sliderRB - kk, 0], 1] * Vector[CornerURB, PP])]], PP, TargetPointsRecB, kk, Sequence[0, numOfRecBelow]) → rectanglesBelowMovable
  45. Sequence(Take[ZoneAll, (ii * comonDen^(2)) + 1, ((ii + 1) * comonDen^(2))], ii, 0, floor(sliderRemainder) - 1) → ZoneAllIntoParts
  46. Last(ZoneAll, sliderLastTiles) → ZoneAllLast
  47. Midpoint(Vertex[Element[ZoneAllLast, lastSquares / 2], 1], Vertex[Element[ZoneAllLast, lastSquares / 2], 3]) → Arrow1
  48. Text(fracAbove, LabelSegAbovePos, true, true, 0, 1) → fracAbovePlaced
  49. Sequence(Flatten[Zip[Sequence[Segment[Vertex[pp, ii], Vertex[pp, If[ii ≟ 4, 1, ii + 1]]], ii, 1, 4], pp, If[Length[ZoneAllIntoParts] ≟ 0, MovableUS, Element[ZoneAllIntoParts, jj]]]], jj, 1, Length[ZoneAllIntoParts]) → auxListForZoneAllBlack
  50. Sequence(Remove[Unique[Element[auxListForZoneAllBlack, ii]], Remove[Element[auxListForZoneAllBlack, ii], Unique[Element[auxListForZoneAllBlack, ii]]]], ii, 1, Length[auxListForZoneAllBlack]) → ZoneAllIntoPartsBlack
  51. Text(fracSide, LablelSegmentSidePos - (0.4, 0), true, true, 0, 0) → fracSidePlaced
  52. Translate(hGuideline, Vector[(Vector[Corner[4], Corner[1]] / 500 * 24)]) → hGuideline'_{1}
  53. Translate(vGuideline, Vector[(Vector[Corner[1], Corner[2]] / 800 * 16)]) → vGuideline'
  54. Translate(hGuideline, Vector[(Vector[Corner[4], Corner[1]] / 500 * 24)]) → hGuideline'
  55. If(numOfRecSide ≟ 0, 98, 24 + 98 + ((500 * hRecSide / comonDen) * 1 / (y(Cor3) - y(Cor1)))) → yPosSliderUT
  56. If(floor(remainder / comonDen^(2)) ≟ 0, yPosSliderUT, yPosSliderUT + 278 - 203.5) → yPosSliderRA

AI Drawing Prompt Reference

Draw a coordinate grid containing a rectangle with mixed number side lengths, where length and width are composed of integer and fractional parts. Partition the rectangle into unit squares and further subdivide into smaller fractional unit squares. Generate two sets of movable small rectangles below and to the right of the main rectangle to represent area partitioning. Different zones inside the rectangle are distinguished by colors or shading, with fraction labels displayed. Include horizontal and vertical grid lines and interactive sliders.
The prompt above was compiled from the original drawing commands and is for reference only.