MathPlotAI Logo MathPlotAI

Deciding Multiplication or Division

Deciding Multiplication or Division
Loading the math board and drawing, please wait…
2020-09-25 23:29
FunctionCoordinate GeometryGeometric Construction
This example demonstrates how to determine multiplication or division through geometric construction. Key mathematical concepts include geometric transformations, coordinate geometry, and function graphing. The construction involves using GeoGebra commands like If, Min, Point, Sequence, etc. It is suitable for middle school students learning the integration of geometry and algebra, and high school students practicing function graph analysis.

GeoGebra Commands & Parameters

  1. If(valid, Min[n1User, n2User], 1) → n2
  2. Min(3 / n2V, 9 / n2H) → n2Spread
  3. First(Flatten[Sequence[Sequence[n2PointsStarter + ((i * n2Spread), (j * n2Spread)), j, 0, n2V - 1], i, 0, n2H - 1]], n2) → n2UnsortedCenters
  4. If(valid, Max[n1User, n2User], 1) → n1
  5. Zip(y(AAA), AAA, n2UnsortedCenters) → n2CentersSorter
  6. Min(3 / n1V, 9 / n1H) → n1Spread
  7. First(Flatten[Sequence[Sequence[n1PointsStarter + ((i * n1Spread), (j * n1Spread)), j, 0, n1V - 1], i, 0, n1H - 1]], n1) → n1UnsortedCenters
  8. Zip(y(AAA), AAA, n1UnsortedCenters) → n1CentersSorter
  9. Point(moverLines) → A
  10. Min(1, Max[Distance[A, (0, 0)] - 0.25, 0]) → darkener
  11. Sort(n1UnsortedCenters, n1CentersSorter) → n1Centers
  12. If(darkener ≟ 1, (Distance[A, (0, 0)] - 1.25) / 2, 0) → move
  13. Sequence(Sequence[Element[n1Centers, j] + ((i * n1Side / n2), 0), i, 0, n2 - 1], j, 1, n1) → n1Dn2StartPoints
  14. Sort(n2UnsortedCenters, n2CentersSorter) → n2Centers
  15. Sequence(First[Flatten[Sequence[Sequence[Element[n2Centers, i] + (n1Dn2EndGap, n1Dn2EndGap) + (((2 * n1Dn2EndGap) * j), ((2 * n1Dn2EndGap) * k)) + ((n1Dn2EndHeight * j), (n1Dn2EndHeight * k)), j, 0, ceil(sqrt(ceil(n1 / n2))) - 1], k, 0, ceil(sqrt(ceil(n1 / n2))) - 1]], ceil(n1 / n2)], i, 1, n2) → n1Dn2EndPointHelper
  16. Zip(Polygon[AAA, AAA + (n2Side, 0), 4], AAA, n2Centers) → n2OrigPolys
  17. Sequence(n2Centers, i, 1, n1) → n1Mn2StartPoints
  18. Sequence(Sequence[Element[n2Centers, j] + ((i * n2Side / n1), 0), i, 0, n1 - 1], j, 1, n2) → n2Dn1StartPoints
  19. Sequence(Sequence[Element[n1Centers, j] + ((i * n1Side / n1), 0), j, 1, n1], i, 0, n2 - 1) → n2Dn1EndPoints
  20. Zip(Polygon[AAA, AAA + (n1Side, 0), 4], AAA, n1Centers) → n1OrigPolys
  21. Flatten(Sequence[Sequence[Sequence[Element[n1Dn2EndPointHelper, i, j] + ((n1Dn2EndHeight / n2 * (k - 1)), 0), k, 1, If[j > floor(n1 / n2), Mod[n1, n2], n2]], j, 1, ceil(n1 / n2)], i, 1, n2]) → n1Dn2UngroupedEndPoints
  22. Sequence(Sequence[Element[n1Dn2UngroupedEndPoints, i + (n1 * j)], j, 0, n2 - 1], i, 1, n1) → n1Dn2EndPoints
  23. If(x(A) > 0, 1, If[y(A) > 0, 2, If[x(A) < 0, 3, 4]]) → index
  24. Sequence(n1Centers, i, 1, n2) → n2Mn1StartPoints
  25. Zip(First[Flatten[Sequence[Sequence[AAA + ((n2Mn1EndGap * ((2 * i) + 1)), (n2Mn1EndGap * ((2 * j) + 1))) + ((i * n2Mn1EndWidth), (j * n2Mn1EndWidth)), i, 0, ceil(sqrt(n1)) - 1], j, 0, ceil(sqrt(n1)) - 1]], n1], AAA, n2Centers) → n2Mn1EndPoints
  26. Zip(First[Flatten[Sequence[Sequence[AAA + ((n1Mn2EndGap * ((2 * i) + 1)), (n1Mn2EndGap * ((2 * j) + 1))) + ((i * n1Mn2EndWidth), (j * n1Mn2EndWidth)), i, 0, ceil(sqrt(n2)) - 1], j, 0, ceil(sqrt(n2)) - 1]], n2], AAA, n1Centers) → n1Mn2EndPoints
  27. Element({n1Mn2StartPoints, n1Dn2StartPoints, n2Mn1StartPoints, n2Dn1StartPoints}, index) → startPoints
  28. Element({n1Mn2EndPoints, n1Dn2EndPoints, n2Mn1EndPoints, n2Dn1EndPoints}, index) → endPoints
  29. First(Sequence[Max[0, Min[1, ((If[index ≥ 3, n2, n1] + 1) / 2 * (move - k / (If[index ≥ 3, n2, n1] + 1)))]], k, 0, If[index ≥ 3, n2, n1] + 1], If[index ≥ 3, n2, n1]) → movers
  30. Element({n2Side, n1Side, n1Side, n2Side}, index) → startHeight
  31. Element({n1Mn2EndHeight, n1Dn2EndHeight, n2Mn1EndHeight, n1Side}, index) → endHeight
  32. Element({n1Mn2EndWidth, n1Dn2EndWidth, n2Mn1EndWidth, n2Dn1EndWidth}, index) → endWidth
  33. Element({n1Mn2StartWidth, n1Dn2StartWidth, n2Mn1StartWidth, n2Dn1StartWidth}, index) → startWidth
  34. Zip((AAA * (1 - CCC)) + (BBB * CCC), AAA, startPoints, BBB, endPoints, CCC, movers) → movingPoints
  35. Sequence(Sequence[Polygon[Element[movingPoints, i, j], Element[movingPoints, i, j] + ((startWidth * (1 - Element[movers, i])) + (endWidth * Element[movers, i]), 0), Element[movingPoints, i, j] + ((startWidth * (1 - Element[movers, i])) + (endWidth * Element[movers, i]), (startHeight * (1 - Element[movers, i])) + (endHeight * Element[movers, i])), Element[movingPoints, i, j] + (0, (startHeight * (1 - Element[movers, i])) + (endHeight * Element[movers, i]))], j, 1, Length[Element[movingPoints, i]]], i, 1, Length[movingPoints]) → movingPolys
  36. Flatten({n1OrigPolys, n2OrigPolys}) → backgrounds
  37. Textfield(n1User) → InputBox1
  38. Textfield(n2User) → InputBox2
  39. Sequence(Sequence[Polygon[Element[n1Dn2EndPointHelper, i, j], Element[n1Dn2EndPointHelper, i, j] + (n1Dn2EndHeight, 0), 4], i, 1, n2], j, 1, (move ≟ 1 ∧ n1 / n2 ≠ floor(n1 / n2)) + Div[Sum[Zip[floor(AAA), AAA, movers]], n2]) → n1Dn2EndWholePolys

AI Drawing Prompt Reference

Draw a geometric figure where the shape and size are determined by the user's input values, deciding between multiplication or division. First, based on the user's input, create multiple small squares or rectangles, which will be scaled and moved according to the input values, forming a dynamic geometric pattern. Finally, based on the user's input, determine the final shape of the figure to show the result of multiplication or division.
The prompt above was compiled from the original drawing commands and is for reference only.