MathPlotAI Logo MathPlotAI

Visualizing Functions of Two Variables (Version 3)

Visualizing Functions of Two Variables (Version 3)
Loading the math board and drawing, please wait…
2017-01-15 19:20
FunctionCalculusSlider AnimationLocusGraphing
① This GeoGebra example demonstrates how to dynamically visualize a function of two variables z=f(x,y) by rendering its surface, contour lines, and related geometric quantities, providing an intuitive understanding of 3D function graphs. ② Core mathematical concepts include bivariate functions, surfaces, level curves (implicit curves), differential equations, volume, and frequency distribution, bridging calculus, analytic geometry, and applied mathematics. ③ Construction highlights: from the summary, commands such as Polygon, ImplicitCurve, IntersectPath, Locus, and PolyLine are used to build surfaces and paths; Sequence, Zip, Text, and Join generate dynamic text and sequences; sliders adjust parameters; Point, Vector, and Line create auxiliary elements; RemoveUndefined, Sum, and Length handle data and computations. ④ Suitable for high school to university-level mathematics instruction, especially for visualizing multivariable calculus, differential equations, and mathematical experiments, as well as for teachers creating interactive courseware.

GeoGebra Commands & Parameters

  1. Polygon((x_{max}, y_{max}), (x_{min}, y_{max}), (x_{min}, y_{min}), (x_{max}, y_{min})) → VV, j, t, c, d
  2. If(b_a, Nx_a, 1) → Nx1_a
  3. Polygon((x((ro; α)), y((ro; α)), z_{min}) + PTest, (x((ro; α + 180°)), y((ro; α + 180°)), z_{min}) + PTest, (x((ro; α + 180°)), y((ro; α + 180°)), z_{max}) + PTest, (x((ro; α)), y((ro; α)), z_{max}) + PTest) → poly1, k, l, m, p
  4. ImplicitCurve(f(x, y) - f(x(C), y(C))) → ICurve_2
  5. IntersectPath(plane0, f(x, y)) → ICurve_3
  6. Point(ICurve_2) → R0
  7. Length(lr2) → llr2
  8. Sequence((x(Element[lr2, i]), y(Element[lr2, i]), f(x(Element[lr2, i]), y(Element[lr2, i]))), i, 1, llr2) → lllPmin01
  9. If(Length[lllPmin01] ≟ 0, false, true) → bwllPmin01
  10. Length(lr1) → llr1
  11. Sequence((x(Element[lr1, i]), y(Element[lr1, i]), f(x(Element[lr1, i]), y(Element[lr1, i]))), i, 1, llr1) → lllPmax01
  12. If(Length[lllPmax01] ≟ 0, false, true) → bwllPmax01
  13. If(bwllPmax01, Max[z(lllPmax01)], 1000) → Maxz0
  14. If(bwllPmax01, IndexOf[Maxz0, Sequence[z(Element[lllPmax01, i]), i, 1, Length[lllPmax01]]], 1000) → Indexmaxz0
  15. If(b, true, false) → h
  16. If(h, Nx, 1) → Nx1
  17. Length(lr3) → llr3
  18. Point(Segment[(0, 0), (6.28319, 0)]) → Af
  19. Point(Segment[Px2, Px1]) → Ax
  20. Point(Segment[Py2, Py1]) → Ay
  21. Textfield(N_{V1}) → inputBox1
  22. Textfield(x_{min}) → inputBox2
  23. Textfield(x_{max}) → inputBox3
  24. Textfield(y_{min}) → inputBox4
  25. Textfield(y_{max}) → inputBox5
  26. Textfield(f) → inputBox6
  27. Textfield(z_{min}) → inputBox7
  28. Textfield(z_{max}) → inputBox8
  29. Point(Segment[Pz2, Pz1]) → Az
  30. Textfield(ω_c) → inputBox9
  31. Textfield(vt) → inputBox10
  32. Sum(Sequence[If[f(x(PTest), y(PTest)) - f(x(Element[lr01, i]), y(Element[lr01, i])) > 0, 1, 0], i, 1, n]) → ext1
  33. RotateText("z_{min}=" + z_{min} + "", 90°) → Text2
  34. RotateText("z_{max}=" + z_{max} + "", 90°) → Text6
  35. Sequence(Segment[Element[l0maxmin2, k], Element[l0maxmin2, k + 1]], k, 1, Length[l0maxmin2]) → linelmaxmin2
  36. Sequence(Element[lr1, i], i, 1, llr1) → lPmax
  37. Sequence(Element[lr2, i], i, 1, llr2) → lPmin
  38. Sequence(Element[lr3, i], i, 1, llr3) → lPsad
  39. If(bwllPmin01, Min[z(lllPmin01)], 1000) → Minz0
  40. If(bwllPmin01, IndexOf[Minz0, Sequence[z(Element[lllPmin01, i]), i, 1, Length[lllPmin01]]], 1000) → Indexminz0
  41. Element(lr2, Indexminz0) → P_{min0}
  42. If(bwllPmin01, Element[lllPmin01, Indexminz0], (1000, 1000, 1000)) → zmin2
  43. Point(Liste1) → C111a
  44. Locus(C1110a, C111a) → loc
  45. PolyLine(l0maxmin1) → linelmaxmin11
  46. If(bwllPmax01, Element[lllPmax01, Indexmaxz0], (1000, 1000, 1000)) → zmax2
  47. RemoveUndefined(Sequence[If[f(x(PTest), y(PTest)) - f(x(Element[lr01, i]), y(Element[lr01, i])) > 0, i, NaN], i, 1, n]) → lr04
  48. Zip(Vector[b, a], a, Sequence[Element[lr01, Element[lr04, i]], i, 1, Length[lr04]], b, Sequence[Element[lr02, Element[lr04, i]], i, 1, Length[lr04]]) → lr06
  49. Sequence((x(Element[lr01, i]), y(Element[lr01, i]), f(x(Element[lr01, i]), y(Element[lr01, i]))), i, 1, n) → lr013
  50. Sequence((x(Element[lr02, i]), y(Element[lr02, i]), f(x(Element[lr02, i]), y(Element[lr02, i]))), i, 1, n) → lr023
  51. Zip(Vector[b, a], a, Sequence[Element[lr013, Element[lr04, i]], i, 1, Length[lr04]], b, Sequence[Element[lr023, Element[lr04, i]], i, 1, Length[lr04]]) → lr063
  52. Zip(Vector[a, b], a, Sequence[Element[lr01, Element[lr05, i]], i, 1, Length[lr05]], b, Sequence[Element[lr02, Element[lr05, i]], i, 1, Length[lr05]]) → lr07
  53. Zip(Vector[a, b], a, Sequence[Element[lr013, Element[lr05, i]], i, 1, Length[lr05]], b, Sequence[Element[lr023, Element[lr05, i]], i, 1, Length[lr05]]) → lr073
  54. Textfield(zoom_{3D}) → InputBox1
  55. Element(lr1, rmax - 1) → Pzmax
  56. Element(lr2, rmin - 1) → Pzmin
  57. Element(lr3, rsad - 1) → Pzsad
  58. Text("( x , y , z )") → TextR01
  59. Join({{TextR01}, lllPmax01}) → llPmax01
  60. Element(lr1, Indexmaxz0) → P_{max0}
  61. Sequence((x(Element[lr3, i]), y(Element[lr3, i]), f(x(Element[lr3, i]), y(Element[lr3, i]))), i, 1, llr3) → lllPsp
  62. Join({{TextR01}, lllPmin01}) → llPmin01
  63. Join({{TextR01}, lllPsp}) → llPsad01
  64. Element(lllPsp, rsad - 1) → Pzsad_{3D}
  65. Element(lllPmax01, rmax - 1) → Pzmax_{3D}
  66. Element(lllPmin01, rmin - 1) → Pzmin_{3D}
  67. Textfield(A) → InputBox2
  68. RemoveUndefined(Sequence[If[f(x(PTest), y(PTest)) - f(x(Element[lr01, i]), y(Element[lr01, i])) > 0, i, (-i)], i, 1, n]) → lr04c
  69. Append(lr04c, Element[lr04c, 1]) → lr04cc
  70. Sum(Sequence[If[(Element[lr04cc, i] * Element[lr04cc, i + 1]) < 0, 1, 0], i, 1, n + 1]) → lr04ccc
  71. Line(A, RoR) → i
  72. ImplicitCurve(f(x, y) - zi) → list3
  73. ImplicitCurve(f(x, y) - zii) → list4
  74. Vector(R0, R41) → w_11
  75. Vector(R0, R0 + R11) → u_11
  76. Textfield(ω0_c) → InputBox3
  77. Textfield(r_a) → InputBox5
  78. Point(c) → G
  79. Point(j) → H
  80. Point(w_11, 1) → I
  81. Vector(F, I_{3D}) → v
  82. If(ext1 ≟ n, 1, If[ext1 ≟ 0, 2, If[lr04ccc > 2 ∧ lr04ccc ≤ 4, 3, 4]]) → roo
  83. Textfield(n_c) → InputBox6
  84. Textfield(a_c) → InputBox7
  85. Textfield(r_{lc}) → InputBox8
  86. Textfield(vt) → InputBox9
  87. PolyLine(Bl) → Bly
  88. PolyLine(Gr) → Gry
  89. PolyLine(Ro) → Roy
  90. Textfield(Nx) → Resolution
  91. Textfield(r) → InputBox11
  92. Textfield(v_{m4}) → InputBox4
  93. Textfield(Nz) → InputBox10
  94. Textfield(n) → InputBox12
  95. Textfield(rr) → InputBox13
  96. Textfield(r_{ext}) → InputBox14
  97. Textfield(v_{zi}) → InputBox15
  98. Textfield(d_1) → InputBox16
  99. Textfield(f_1) → InputBox17
  100. Textfield(v_{m3}) → InputBox18

AI Drawing Prompt Reference

Create a 3D plot of a bivariate function surface with contour lines, extreme points (maxima, minima, and saddle points), and cross-sectional curves along specified directions. Include a rectangular base region, adjustable sliders and input fields for function expression, coordinate ranges, and parameters. Highlight extreme points with distinct colors and display their numerical labels. Also show intersection curves with a plane and gradient vectors or trajectories from extreme points. The overall layout includes coordinate axes, grid, and dynamic text for interactive exploration.
The prompt above was compiled from the original drawing commands and is for reference only.