--- title: "StreamPlot" language: "en" type: "Symbol" summary: "StreamPlot[{vx, vy}, {x, xmin, xmax}, {y, ymin, ymax}] generates a stream plot of the vector field {vx, vy} as a function of x and y. StreamPlot[{{vx, vy}, {wx, wy}, ...}, {x, xmin, xmax}, {y, ymin, ymax}] generates plots of several vector fields. StreamPlot[..., {x, y} \\[Element] reg] takes the variables {x, y} to be in the geometric region reg." keywords: - streamlines - flow lines - path lines - phase portrait - vector field plot - vector plot - vector field visualization - vector visualization canonical_url: "https://reference.wolfram.com/language/ref/StreamPlot.html" source: "Wolfram Language Documentation" related_guides: - title: "Vector Visualization" link: "https://reference.wolfram.com/language/guide/VectorVisualization.en.md" - title: "Function Visualization" link: "https://reference.wolfram.com/language/guide/FunctionVisualization.en.md" - title: "Vector Analysis" link: "https://reference.wolfram.com/language/guide/VectorAnalysis.en.md" - title: "Differential Equations" link: "https://reference.wolfram.com/language/guide/DifferentialEquations.en.md" - title: "Solvers over Regions" link: "https://reference.wolfram.com/language/guide/GeometricSolvers.en.md" related_functions: - title: "VectorPlot" link: "https://reference.wolfram.com/language/ref/VectorPlot.en.md" - title: "StreamPlot3D" link: "https://reference.wolfram.com/language/ref/StreamPlot3D.en.md" - title: "StreamDensityPlot" link: "https://reference.wolfram.com/language/ref/StreamDensityPlot.en.md" - title: "ListStreamPlot" link: "https://reference.wolfram.com/language/ref/ListStreamPlot.en.md" - title: "LineIntegralConvolutionPlot" link: "https://reference.wolfram.com/language/ref/LineIntegralConvolutionPlot.en.md" - title: "ParametricPlot" link: "https://reference.wolfram.com/language/ref/ParametricPlot.en.md" - title: "ContourPlot" link: "https://reference.wolfram.com/language/ref/ContourPlot.en.md" - title: "DensityPlot" link: "https://reference.wolfram.com/language/ref/DensityPlot.en.md" - title: "Plot3D" link: "https://reference.wolfram.com/language/ref/Plot3D.en.md" - title: "VectorPlot3D" link: "https://reference.wolfram.com/language/ref/VectorPlot3D.en.md" - title: "SliceVectorPlot3D" link: "https://reference.wolfram.com/language/ref/SliceVectorPlot3D.en.md" --- # StreamPlot StreamPlot[{vx, vy}, {x, xmin, xmax}, {y, ymin, ymax}] generates a stream plot of the vector field {vx, vy} as a function of x and y. StreamPlot[{{vx, vy}, {wx, wy}, …}, {x, xmin, xmax}, {y, ymin, ymax}] generates plots of several vector fields. StreamPlot[…, {x, y}∈reg] takes the variables {x, y} to be in the geometric region reg. ## Details and Options * ``StreamPlot`` is known as a streamline plot. * ``StreamPlot`` plots streamlines $\sigma _i(t)$ defined by $\sigma _i'(t)=v\left(\sigma _i(t)\right)$ and $\sigma _i(0)=p_i$, where $v(\{x,y\})=\left\{v_x,v_y\right\}$ and $p_i$ is an initial stream point. The streamline $\sigma _i(t)$ is the curve passing through point $p_i$, and whose tangents correspond to the vector field $v$ at each point. * The streamlines are colored by default according to the magnitude $s$ of the vector field $\left\| \left\{v_x,v_y\right\}\right\|$ and have an arrow in the direction of increasing value of $t$. [image] * ``StreamPlot`` by default shows enough streamlines to achieve a roughly uniform density throughout the plot, and shows no background scalar field. * ``StreamPlot`` does not show streamlines at any positions for which the ``vi`` etc. do not evaluate to real numbers. * ``StreamPlot`` treats the variables ``x`` and ``y`` as local, effectively using ``Block``. * ``StreamPlot`` has attribute ``HoldAll``, and evaluates the ``vi`` etc. only after assigning specific numerical values to ``x`` and ``y``. * In some cases it may be more efficient to use ``Evaluate`` to evaluate the ``vi`` etc. symbolically before specific numerical values are assigned to ``x`` and ``y``. * ``StreamPlot`` has the same options as ``Graphics``, with the following additions and changes: [] | | | | | --------------------------- | ----------------- | --------------------------------------------------------- | | AspectRatio | 1 | ratio of height to width | | EvaluationMonitor | None | expression to evaluate at every function evaluation | | Frame | True | whether to draw a frame around the plot | | FrameTicks | Automatic | frame tick marks | | Method | Automatic | methods to use for the plot | | PerformanceGoal | \$PerformanceGoal | aspects of performance to try to optimize | | PlotLayout | Automatic | how to position fields | | PlotLegends | None | legends to include | | PlotRange | {Full, Full} | range of x, y values to include | | PlotRangePadding | Automatic | how much to pad the range of values | | PlotTheme | \$PlotTheme | overall theme for the plot | | RegionBoundaryStyle | Automatic | how to style plot region boundaries | | RegionFillingStyle | Automatic | how to style plot region interiors | | RegionFunction | (True&) | determine what region to include | | ScalingFunctions | None | how to scale individual coordinates | | StreamColorFunction | Automatic | how to color streamlines | | StreamColorFunctionScaling | True | whether to scale the argument to StreamColorFunction | | StreamMarkers | Automatic | shape to use for streams | | StreamPoints | Automatic | determine number, placement, and closeness of streamlines | | StreamScale | Automatic | determine sizes and segmenting of individual streamlines | | StreamStyle | Automatic | how to draw streamlines | | WorkingPrecision | MachinePrecision | precision to use in internal computations | * The arguments supplied to functions in ``RegionFunction`` and ``StreamColorFunction`` are ``x``, ``y``, ``vx``, ``vy``, ``Norm[{vx, vy}]``. * Possible settings for ``PlotLayout`` that show single streamlines in multiple plot panels include: | | | | ------------------------------------- | ---------------------------------------------- | | "Column" | use separate streamlines in a column of panels | | "Row" | use separate streamlines in a row of panels | | {"Column", k}, {"Row", k} | use k columns or rows | | {"Column", UpTo[k]}, {"Row", UpTo[k]} | use at most k columns or rows | [image] * Possible settings for ``ScalingFunctions`` are: {Subscript[``s``, ``x``], Subscript[``s``, ``y``]} scale ``x`` and ``y`` axes * Common built-in scaling functions ``s`` include: | | | | | ----------- | ------- | --------------------------------------------------- | | "Log" | [image] | log scale with automatic tick labeling | | "Log10" | [image] | base-10 log scale with powers of 10 for ticks | | "SignedLog" | [image] | log-like scale that includes 0 and negative numbers | | "Reverse" | [image] | reverse the coordinate direction | | "Infinite" | [image] | infinite scale | ### List of all options | | | | | -------------------------- | ----------------- | ---------------------------------------------------------------------------------- | | AlignmentPoint | Center | the default point in the graphic to align with | | AspectRatio | 1 | ratio of height to width | | Axes | False | whether to draw axes | | AxesLabel | None | axes labels | | AxesOrigin | Automatic | where axes should cross | | AxesStyle | {} | style specifications for the axes | | Background | None | background color for the plot | | BaselinePosition | Automatic | how to align with a surrounding text baseline | | BaseStyle | {} | base style specifications for the graphic | | ContentSelectable | Automatic | whether to allow contents to be selected | | CoordinatesToolOptions | Automatic | detailed behavior of the coordinates tool | | Epilog | {} | primitives rendered after the main plot | | EvaluationMonitor | None | expression to evaluate at every function evaluation | | FormatType | TraditionalForm | the default format type for text | | Frame | True | whether to draw a frame around the plot | | FrameLabel | None | frame labels | | FrameStyle | {} | style specifications for the frame | | FrameTicks | Automatic | frame tick marks | | FrameTicksStyle | {} | style specifications for frame ticks | | GridLines | None | grid lines to draw | | GridLinesStyle | {} | style specifications for grid lines | | ImageMargins | 0. | the margins to leave around the graphic | | ImagePadding | All | what extra padding to allow for labels etc. | | ImageSize | Automatic | the absolute size at which to render the graphic | | LabelStyle | {} | style specifications for labels | | Method | Automatic | methods to use for the plot | | PerformanceGoal | \$PerformanceGoal | aspects of performance to try to optimize | | PlotLabel | None | an overall label for the plot | | PlotLayout | Automatic | how to position fields | | PlotLegends | None | legends to include | | PlotRange | {Full, Full} | range of x, y values to include | | PlotRangeClipping | False | whether to clip at the plot range | | PlotRangePadding | Automatic | how much to pad the range of values | | PlotRegion | Automatic | the final display region to be filled | | PlotTheme | \$PlotTheme | overall theme for the plot | | PreserveImageOptions | Automatic | whether to preserve image options when displaying new versions of the same graphic | | Prolog | {} | primitives rendered before the main plot | | RegionBoundaryStyle | Automatic | how to style plot region boundaries | | RegionFillingStyle | Automatic | how to style plot region interiors | | RegionFunction | (True&) | determine what region to include | | RotateLabel | True | whether to rotate y labels on the frame | | ScalingFunctions | None | how to scale individual coordinates | | StreamColorFunction | Automatic | how to color streamlines | | StreamColorFunctionScaling | True | whether to scale the argument to StreamColorFunction | | StreamMarkers | Automatic | shape to use for streams | | StreamPoints | Automatic | determine number, placement, and closeness of streamlines | | StreamScale | Automatic | determine sizes and segmenting of individual streamlines | | StreamStyle | Automatic | how to draw streamlines | | Ticks | Automatic | axes ticks | | TicksStyle | {} | style specifications for axes ticks | | WorkingPrecision | MachinePrecision | precision to use in internal computations | --- ## Examples (150) ### Basic Examples (4) Plot the streamlines with arrows for the field $\left\{-x^2+y-1,x-y^2+1\right\}$ : ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}] Out[1]= [image] ``` --- Include a legend for the field magnitude: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotLegends -> Automatic] Out[1]= [image] ``` --- Visualize streamlines as unbroken lines: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamScale -> None] Out[1]= [image] ``` --- Use a multi-panel layout to show multiple vector fields at the same time: ```wl In[1]:= StreamPlot[{{x + y, y - x}, {y, x + y}}, {x, -3, 3}, {y, -3, 3}, PlotLayout -> "Row"] Out[1]= [image] ``` ### Scope (22) #### Sampling (10) Plot a vector field with streamlines placed with specified densities: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotLabel -> p, StreamPoints -> p], {p, {Coarse, Medium, Automatic, Fine}}] Out[1]= [image] ``` --- Plot the streamlines that go through a set of seed points: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamPoints -> Tuples[{-2, 0, 2}, 2], Epilog -> Point[Tuples[{-2, 0, 2}, 2]]] Out[1]= [image] ``` --- Use both automatic and explicit seeding with styles for explicitly seeded streamlines: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> None, StreamPoints -> {{{{1, 0}, Red}, {{-1, -1}, Green}, Automatic}}] Out[1]= [image] ``` --- Plot streamlines over a specified region: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, RegionFunction -> Function[{x, y, vx, vy, n}, x y < 0]] Out[1]= [image] ``` --- Plot multiple vector fields: ```wl In[1]:= StreamPlot[{{x, y}, {y, -x}}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> None] Out[1]= [image] ``` --- Use a specific number of mesh lines: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> 5] Out[1]= [image] ``` --- Specify specific mesh lines: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> {{2, 4, 5}}] Out[1]= [image] ``` --- Use ``Evaluate`` to evaluate the vector field symbolically before numeric assignment: ```wl In[1]:= StreamPlot[Evaluate[D[Sin[x y], {{x, y}}]], {x, 0, 1}, {y, 0, 1}] Out[1]= [image] ``` --- The domain may be specified by a region: ```wl In[1]:= StreamPlot[{y, -x}, {x, y}∈Disk[]] Out[1]= [image] ``` --- The domain may be specified by a ``MeshRegion`` : ```wl In[1]:= \[ScriptCapitalD] = MeshRegion[{{0, 0}, {5, -2}, {3, 0}, {5, 2}}, Polygon[{1, 2, 3, 4}]]; In[2]:= StreamPlot[{Sin[x], Cos[y]}, {x, y}∈\[ScriptCapitalD]] Out[2]= [image] ``` #### Presentation (12) Specify different dashings and arrowheads by setting to ``StreamScale`` : ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotLabel -> ToString@s, StreamScale -> s], {s, {Automatic, None, Full}}] Out[1]= {[image], [image], [image]} ``` --- Plot the streamlines with arrows colored according to the magnitude of the field: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> Automatic] Out[1]= [image] ``` --- Apply a variety of streamline styles: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamScale -> Full, StreamStyle -> s], {s, {"Toothpick", "Dart", Directive[Orange, Dashed], Arrowheads[{{0.03, Automatic, Graphics[Circle[]]}}]}}] Out[1]= [image] ``` --- Use a theme with axes: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotTheme -> "Scientific"] Out[1]= [image] ``` Override the style from the theme: ```wl In[2]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotTheme -> "Scientific", StreamColorFunction -> None, StreamStyle -> Black] Out[2]= [image] ``` --- Use a named appearance to draw the streamlines: ```wl In[1]:= StreamPlot[{y, -x}, {x, -3, 3}, {y, -3, 3}, StreamMarkers -> "Drop"] Out[1]= [image] ``` Style the streamlines as well: ```wl In[2]:= StreamPlot[{y, -x}, {x, -3, 3}, {y, -3, 3}, StreamMarkers -> "Drop", StreamColorFunction -> None, StreamStyle -> Red] Out[2]= [image] ``` --- Specify mesh lines with different styles: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> {{{2, Thick}, {4, Green}, {5, {Thick, Red, Dashed}}}}] Out[1]= [image] ``` --- Specify global mesh line styles: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> 10, MeshStyle -> s], {s, {Red, Thick, Directive[Red, Dashed]}}] Out[1]= [image] ``` --- Shade mesh regions cyclically: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> 10, MeshShading -> {Red, Yellow, Green, None}] Out[1]= [image] ``` --- Apply a variety of styles to region boundaries: ```wl In[1]:= regionFn = Function[{x, y, vx, vy, n}, 4 < n < 6 || 0 < n < 2]; In[2]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, RegionFunction -> regionFn, RegionBoundaryStyle -> b], {b, {Red, Thick, Directive[Red, Dashed]}}] Out[2]= [image] ``` --- Show multiple functions as densities in separate panels: ```wl In[1]:= StreamPlot[{{x, y}, {y, -x}}, {x, -3, 3}, {y, -3, 3}, PlotLayout -> "Row"] Out[1]= [image] ``` Use a column instead of a row: ```wl In[2]:= StreamPlot[{{x, y}, {y, -x}}, {x, -3, 3}, {y, -3, 3}, PlotLayout -> "Column"] Out[2]= [image] ``` --- Add a legend with placeholder text: ```wl In[1]:= StreamPlot[{{x, y}, {y, -x}}, {x, -3, 3}, {y, -3, 3}, PlotLegends -> Automatic, StreamColorFunction -> None] Out[1]= [image] ``` Use the vector fields as legend labels: ```wl In[2]:= StreamPlot[{{x, y}, {y, -x}}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> None, PlotLegends -> "Expressions"] Out[2]= [image] ``` Use explicit labels for each vector field: ```wl In[3]:= StreamPlot[{{x, y}, {y, -x}}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> None, PlotLegends -> {"radial", "angular"}] Out[3]= [image] ``` --- Use a log scale for the ``x`` axis: ```wl In[1]:= StreamPlot[{x, y}, {x, 1, 100}, {y, 1, 10}, ScalingFunctions -> {"Log", None}] Out[1]= [image] ``` Reverse the ``y`` scale so it increases toward the bottom: ```wl In[2]:= StreamPlot[{x, y}, {x, 1, 100}, {y, 1, 100}, ScalingFunctions -> {None, "Reverse"}] Out[2]= [image] ``` ### Options (97) #### AspectRatio (3) By default, ``StreamPlot`` uses the same width and height: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -2, 2}] Out[1]= [image] ``` --- Use numerical value to specify the height to width ratio: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -2, 2}, AspectRatio -> 1 / 2] Out[1]= [image] ``` --- ``AspectRatio -> Automatic`` determines the ratio from the plot ranges: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -2, 2}, AspectRatio -> Automatic] Out[1]= [image] ``` #### Axes (4) By default, ``StreamPlot`` uses a frame instead of axes: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False] Out[1]= [image] ``` --- Use axes instead of a frame: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True] Out[1]= [image] ``` --- Use ``AxesOrigin`` to specify where the axes intersect: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True, AxesOrigin -> {1, 1}] Out[1]= [image] ``` --- Turn each axis on individually: ```wl In[1]:= {StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> {True, False}], StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> {False, True}]} Out[1]= [image] ``` #### AxesLabel (3) No axes labels are drawn by default: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True] Out[1]= [image] ``` --- Place a label on the $y$ axis: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True, AxesLabel -> y] Out[1]= [image] ``` --- Specify axes labels: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True, AxesLabel -> {x, y}] Out[1]= [image] ``` #### AxesOrigin (2) The position of the axes is determined automatically: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True] Out[1]= [image] ``` --- Specify an explicit origin for the axes: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True, AxesOrigin -> {2, 2}] Out[1]= [image] ``` #### AxesStyle (4) Change the style for the axes: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True, AxesStyle -> Red] Out[1]= [image] ``` --- Specify the style of each axis: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True, AxesStyle -> {Red, Blue}] Out[1]= [image] ``` --- Use different styles for the ticks and the axes: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True, AxesStyle -> Green, TicksStyle -> Black] Out[1]= [image] ``` --- Use different styles for the labels and the axes: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, Frame -> False, Axes -> True, AxesStyle -> Green, LabelStyle -> Black] Out[1]= [image] ``` #### Background (1) Use colored backgrounds: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> None, StreamStyle -> Blue, FrameStyle -> Gray, Background -> LightGray] Out[1]= [image] ``` #### EvaluationMonitor (2) Show where the vector field function is sampled: ```wl In[1]:= ListPlot[Reap[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, EvaluationMonitor :> Sow[{x, y}]]][[-1, 1]]] Out[1]= [image] ``` --- Count the number of times the vector field function is evaluated: ```wl In[1]:= Block[{k = 0}, StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, EvaluationMonitor :> k++];k] Out[1]= 3592 ``` #### ImageSize (5) Use named sizes such as ``Tiny``, ``Small``, ``Medium`` and ``Large`` : ```wl In[1]:= {StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, ImageSize -> Tiny], StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, ImageSize -> Small]} Out[1]= [image] ``` --- Specify the width of the plot: ```wl In[1]:= {StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, ImageSize -> 150], StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, AspectRatio -> 1.5, ImageSize -> 150]} Out[1]= [image] ``` Specify the height of the plot: ```wl In[2]:= {StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, ImageSize -> {Automatic, 150}], StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, AspectRatio -> 2, ImageSize -> {Automatic, 150}]} Out[2]= [image] ``` --- Allow the width and height to be up to a certain size: ```wl In[1]:= {StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, ImageSize -> UpTo[200]], StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, AspectRatio -> 2, ImageSize -> UpTo[200]]} Out[1]= [image] ``` --- Specify the width and height for a graphic, padding with space if necessary: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, ImageSize -> {300, 200}, Background -> LightBlue] Out[1]= [image] ``` --- Use maximum sizes for the width and height: ```wl In[1]:= {StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, ImageSize -> {UpTo[150], UpTo[100]}], StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -2, 2}, {y, -3, 3}, AspectRatio -> 2, ImageSize -> {UpTo[150], UpTo[100]}]} Out[1]= [image] ``` #### Mesh (5) By default, no mesh lines are displayed: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> None] Out[1]= [image] ``` --- Show the final sampling mesh: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> All] Out[1]= [image] ``` --- Use a specific number of mesh lines: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> 5] Out[1]= [image] ``` --- Specify mesh lines: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> {{2, 4, 5}}] Out[1]= [image] ``` --- Use different styles for different mesh lines: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> {{{2, Thick}, {4, Green}, {5, {Thick, Red, Dashed}}}}] Out[1]= [image] ``` #### MeshFunctions (3) By default, mesh lines correspond to the magnitude of the field: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, MeshFunctions -> Function[{x, y, vx, vy, n}, n], Mesh -> 5] Out[1]= [image] ``` --- Use the $x$ value as the mesh function: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, MeshFunctions -> Function[{x, y, vx, vy, n}, x], Mesh -> 5] Out[1]= [image] ``` --- Use mesh lines corresponding to fixed distances from the origin: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, MeshFunctions -> Function[{x, y, vx, vy, n}, Sqrt[x ^ 2 + y ^ 2]], Mesh -> 5] Out[1]= [image] ``` #### MeshShading (3) Use ``None`` to remove regions: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> 10, MeshShading -> {Red, None}] Out[1]= [image] ``` --- Styles are used cyclically: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> 10, MeshShading -> {Red, Yellow, Green, None}] Out[1]= [image] ``` --- Use indexed colors from ``ColorData`` cyclically: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> 10, MeshShading -> ColorData[51, "ColorList"]] Out[1]= [image] ``` #### MeshStyle (1) Apply a variety of styles to the mesh lines: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, Mesh -> 10, MeshStyle -> s], {s, {Red, Thick, Directive[Red, Dashed]}}] Out[1]= [image] ``` #### PerformanceGoal (2) Generate a higher-quality plot: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PerformanceGoal -> "Quality"] Out[1]= [image] ``` --- Emphasize performance, possibly at the cost of quality: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PerformanceGoal -> "Speed"] Out[1]= [image] ``` #### PlotLayout (2) Place each group of vectors in a separate panel using shared axes: ```wl In[1]:= StreamPlot[{{y, -x}, {x, y}}, {x, -3, 3}, {y, -3, 3}, ImageSize -> Medium, PlotLayout -> "Column"] Out[1]= [image] ``` Use a row instead of a column: ```wl In[2]:= StreamPlot[{{y, -x}, {x, y}}, {x, -3, 3}, {y, -3, 3}, ImageSize -> Medium, PlotLayout -> "Row"] Out[2]= [image] ``` --- Use multiple columns or rows: ```wl In[1]:= StreamPlot[{{y, -x}, {x, y}, {y, x + y}, {x, x - y}}, {x, -3, 3}, {y, -3, 3}, ImageSize -> Medium, PlotLayout -> {"Column", 2}] Out[1]= [image] ``` Prefer full columns or rows: ```wl In[2]:= StreamPlot[{{y, -x}, {x, y}, {y, x + y}, {x, x - y}, {x + y, x}, {y - x, x + y}}, {x, -3, 3}, {y, -3, 3}, ImageSize -> Medium, PlotLayout -> {"Column", UpTo[4]}] Out[2]= [image] In[3]:= StreamPlot[{{y, -x}, {x, y}, {y, x + y}, {x, x - y}, {x + y, x}, {y - x, x + y}}, {x, -3, 3}, {y, -3, 3}, ImageSize -> Medium, PlotLayout -> {"Column", 4}] Out[3]= [image] ``` #### PlotLegends (6) No legends are included by default: ```wl In[1]:= StreamPlot[{y, Exp[-x]}, {x, -3, 3}, {y, -3, 3}] Out[1]= [image] ``` --- Include a legend to show the color range of field norms: ```wl In[1]:= StreamPlot[{y, Exp[-x]}, {x, -3, 3}, {y, -3, 3}, PlotLegends -> Automatic] Out[1]= [image] ``` --- Control the placement of the legend: ```wl In[1]:= StreamPlot[{y, Exp[-x]}, {x, -3, 3}, {y, -3, 3}, PlotLegends -> Placed[Automatic, Below]] Out[1]= [image] ``` --- Include a legend for multiple fields: ```wl In[1]:= StreamPlot[{{x, y}, {y, -x}}, {x, -3, 3}, {y, -3, 3}, PlotLegends -> {"one", "two"}, StreamColorFunction -> None] Out[1]= [image] ``` --- Use the vector fields as the legend text: ```wl In[1]:= StreamPlot[{{x, y}, {y, -x}}, {x, -3, 3}, {y, -3, 3}, PlotLegends -> "Expressions", StreamColorFunction -> None] Out[1]= [image] ``` Use placeholder text: ```wl In[2]:= StreamPlot[{{x, y}, {y, -x}}, {x, -3, 3}, {y, -3, 3}, PlotLegends -> Automatic, StreamColorFunction -> None] Out[2]= [image] ``` --- Change the appearance of the legend: ```wl In[1]:= StreamPlot[{{x, y}, {y, -x}}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> None, StreamStyle -> {Red, Blue}, PlotLegends -> SwatchLegend["Expressions", LegendMarkerSize -> {40, 10}]] Out[1]= [image] ``` #### PlotRange (5) The full plot range is used by default: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotRange -> Full] Out[1]= [image] ``` --- Specify an explicit limit for both $x$ and $y$ ranges: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotRange -> 2] Out[1]= [image] ``` --- Specify an explicit $x$ range: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotRange -> {{0, Full}, Automatic}] Out[1]= [image] ``` --- Specify an explicit $y$ range: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotRange -> {Full, {0, 2}}] Out[1]= [image] ``` --- Specify different $x$ and $y$ ranges: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotRange -> {{-2, 1.5}, {-1, 2}}] Out[1]= [image] ``` #### PlotTheme (2) Use a theme with simpler ticks and brighter colors: ```wl In[1]:= StreamPlot[{Cos[x], Sin[y]}, {x, -3, 3}, {y, -3, 3}, PlotTheme -> "Web"] Out[1]= [image] ``` --- Use a theme with dense streamlines: ```wl In[1]:= StreamPlot[{{Cos[x], Sin[y]}, {-Sin[y], Cos[x]}}, {x, -3, 3}, {y, -3, 3}, PlotTheme -> "Detailed"] Out[1]= [image] ``` Change the stream styles: ```wl In[2]:= StreamPlot[{{Cos[x], Sin[y]}, {-Sin[y], Cos[x]}}, {x, -3, 3}, {y, -3, 3}, PlotTheme -> "Detailed", StreamStyle -> {Red, Blue}, StreamColorFunction -> None] Out[2]= [image] ``` #### RegionBoundaryStyle (2) By default, region boundaries are styled: ```wl In[1]:= regionFn = Function[{x, y, vx, vy, n}, 4 < n < 6 || 0 < n < 2]; In[2]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, RegionFunction -> regionFn] Out[2]= [image] ``` Show no boundaries and filling: ```wl In[3]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, RegionFunction -> regionFn, RegionBoundaryStyle -> None, RegionFillingStyle -> None] Out[3]= [image] ``` --- Apply a variety of styles to region boundaries: ```wl In[1]:= regionFn = Function[{x, y, vx, vy, n}, 4 < n < 6 || 0 < n < 2]; In[2]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, RegionFunction -> regionFn, RegionBoundaryStyle -> b], {b, {Red, Thick, Directive[Red, Dashed]}}] Out[2]= [image] ``` #### RegionFillingStyle (1) By default, region filling is styled: ```wl In[1]:= regionFn = Function[{x, y, vx, vy, n}, 4 < n < 6 || 0 < n < 2]; In[2]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, RegionFunction -> regionFn] Out[2]= [image] ``` Show no filling: ```wl In[3]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, RegionFunction -> regionFn, RegionFillingStyle -> None] Out[3]= [image] ``` #### RegionFunction (3) Plot streamlines only over certain quadrants: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, RegionFunction -> Function[{x, y, vx, vy, n}, x y < 0]] Out[1]= [image] ``` --- Plot streamlines only over regions where the field magnitude is above a given threshold: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, RegionFunction -> Function[{x, y, vx, vy, n}, n < 6]] Out[1]= [image] ``` --- Use any logical combination of conditions: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, RegionFunction -> Function[{x, y, vx, vy, n}, 3 < n < 6 || 0 < n < 2]] Out[1]= [image] ``` #### ScalingFunctions (2) Use a log scale for the ``x`` axis: ```wl In[1]:= StreamPlot[{x, y}, {x, 1, 100}, {y, 1, 10}, ScalingFunctions -> {"Log", None}] Out[1]= [image] ``` --- Reverse the ``y`` scale so it increases toward the bottom: ```wl In[1]:= StreamPlot[{x, y}, {x, 1, 100}, {y, 1, 100}, ScalingFunctions -> {None, "Reverse"}] Out[1]= [image] ``` #### StreamColorFunction (5) By default, color streamlines according to the norm of the vector field: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}] Out[1]= [image] ``` --- Use any named color gradient from ``ColorData``: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> "Rainbow"] Out[1]= [image] ``` --- Use ``ColorData`` for predefined color gradients: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> Function[{x, y, vx, vy, n}, ColorData["AvocadoColors"][x y]]] Out[1]= [image] ``` --- Specify a color function that blends two colors by the $x$ coordinate: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> Function[{x, y, vx, vy, n}, Blend[{Blue, Red}, x]]] Out[1]= [image] ``` --- Use ``StreamColorFunctionScaling -> False`` to get unscaled values: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunctionScaling -> False, StreamColorFunction -> Function[{x, y, vx, vy, n}, ColorData[22][Round[n]]]] Out[1]= [image] ``` #### StreamColorFunctionScaling (4) By default, scaled values are used: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> Function[{x, y, vx, vy, n}, Blend[{Blue, Red}, x]]] Out[1]= [image] ``` --- Use ``StreamColorFunctionScaling -> False`` to get unscaled values: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunctionScaling -> False, StreamColorFunction -> Function[{x, y, vx, vy, n}, ColorData[22][Round[n]]]] Out[1]= [image] ``` --- Use unscaled coordinates in the $x$ direction and scaled coordinates in the $y$ direction: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> Function[{x, y, vx, vy, n}, Hue[x, y, 1]], StreamColorFunctionScaling -> {False, True}] Out[1]= [image] ``` --- Explicitly specify the scaling for each color function argument: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> Function[{x, y, vx, vy, n}, Hue[n, y, 1]], StreamColorFunctionScaling -> {True, True, True, True, False}] Out[1]= [image] ``` #### StreamMarkers (7) Streamlines are drawn as arrows by default: ```wl In[1]:= StreamPlot[{y, -x}, {x, -3, 3}, {y, -3, 3}] Out[1]= [image] ``` --- Use a named appearance to draw the streamlines: ```wl In[1]:= StreamPlot[{y, -x}, {x, -3, 3}, {y, -3, 3}, StreamMarkers -> "Drop"] Out[1]= [image] ``` --- Use different markers for different vector fields: ```wl In[1]:= StreamPlot[{{y, -x}, {x, y}}, {x, -3, 3}, {y, -3, 3}, StreamScale -> Large, StreamPoints -> Coarse, StreamMarkers -> {"Drop", "Dart"}] Out[1]= [image] ``` --- Named arrow styles: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotLabel -> s, StreamScale -> {Full, All, 0.05}, StreamMarkers -> s], {s, {"Arrow", "ArrowArrow", "CircleArrow"}}] Out[1]= {[image], [image], [image]} ``` --- Named dot styles: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotLabel -> s, StreamScale -> {Full, All, 0.03}, StreamMarkers -> s], {s, {"BarDot", "Dot", "DotArrow", "DotDot"}}] Out[1]= [image] ``` --- Named pointer styles: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotLabel -> s, StreamScale -> {Full, All, 0.03}, StreamMarkers -> s], {s, {"Drop", "BackwardPointer", "Pointer", "Toothpick"}}] Out[1]= [image] ``` --- Named dart styles: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotLabel -> s, StreamScale -> {Full, All, 0.03}, StreamMarkers -> s], {s, {"Dart", "PinDart", "DoubleDart"}}] Out[1]= [image] ``` #### StreamPoints (6) Specify a specific maximum number of streamlines: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamPoints -> 10] Out[1]= [image] ``` --- Use symbolic names to specify the number of streamlines: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamPoints -> p, PlotLabel -> p], {p, {Automatic, Coarse, Fine}}] Out[1]= [image] ``` --- Use both automatic and explicit seeding with styles for explicitly seeded streamlines: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamColorFunction -> None, StreamPoints -> {{{{1, 0}, Red}, {{-1, -1}, Green}, Automatic}}] Out[1]= [image] ``` --- Specify the minimum distance between streamlines: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotLabel -> d, StreamPoints -> {Automatic, d}], {d, {Automatic, 1, Scaled[0.05]}}] Out[1]= {[image], [image], [image]} ``` --- Specify the minimum distance between streamlines at the start and end of a streamline: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, PlotLabel -> d, StreamPoints -> {Automatic, d}], {d, {Automatic, {Scaled[0.1], Scaled[0.5]}}}] Out[1]= {[image], [image]} ``` --- Control the maximum length that each streamline can have: ```wl In[1]:= points = Tuples[{-2, 0, 2}, 2] Out[1]= {{-2, -2}, {-2, 0}, {-2, 2}, {0, -2}, {0, 0}, {0, 2}, {2, -2}, {2, 0}, {2, 2}} In[2]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamPoints -> {points, Automatic, maxlen}, Epilog -> Point[points]], {maxlen, {2.5, Scaled[0.2]}}] Out[2]= {[image], [image]} ``` #### StreamScale (9) Create full streamlines without segmentation: ```wl In[1]:= StreamPlot[{Sin[x], Cos[y]}, {x, -Pi, Pi}, {y, -Pi, Pi}, StreamPoints -> 10, StreamScale -> Full] Out[1]= [image] ``` --- Use curves for streamlines: ```wl In[1]:= StreamPlot[{Sin[x], Cos[y]}, {x, -Pi, Pi}, {y, -Pi, Pi}, StreamPoints -> 10, StreamScale -> None] Out[1]= [image] ``` --- Use symbolic names to control the lengths of streamlines: ```wl In[1]:= Table[StreamPlot[{Sin[x], Cos[y]}, {x, -Pi, Pi}, {y, -Pi, Pi}, PlotLabel -> s, StreamScale -> s], {s, {Tiny, Large}}] Out[1]= [image] ``` --- Specify segment lengths: ```wl In[1]:= Table[StreamPlot[{Sin[x], Cos[y]}, {x, -Pi, Pi}, {y, -Pi, Pi}, PlotLabel -> s, StreamScale -> s], {s, {0.1, 0.2, 0.4}}] Out[1]= {[image], [image], [image]} ``` --- Specify an explicit dashing pattern for streamlines: ```wl In[1]:= StreamPlot[{Sin[x], Cos[y]}, {x, -Pi, Pi}, {y, -Pi, Pi}, StreamScale -> {{0.1, 0.1}, Automatic}] Out[1]= [image] ``` --- Specify the number of points rendered on each streamline segment: ```wl In[1]:= Table[StreamPlot[{y, -x}, {x, -Pi, Pi}, {y, -Pi, Pi}, PlotLabel -> n, StreamScale -> {Full, n}], {n, {12, 24, All}}] Out[1]= {[image], [image], [image]} ``` --- Specify absolute aspect ratios relative to the longest line segment: ```wl In[1]:= Table[StreamPlot[{Sin[x], Cos[y]}, {x, -Pi, Pi}, {y, -Pi, Pi}, StreamPoints -> 10, PlotLabel -> a, StreamScale -> {Automatic, Automatic, a}], {a, {.02, .04}}] Out[1]= [image] ``` --- Specify relative aspect ratios relative to each line segment: ```wl In[1]:= Table[StreamPlot[{Sin[x], Cos[y]}, {x, -Pi, Pi}, {y, -Pi, Pi}, StreamPoints -> 10, PlotLabel -> a, StreamScale -> {Automatic, Automatic, a}], {a, {Scaled[0.5], Scaled[1], Scaled[1.5]}}] Out[1]= {[image], [image], [image]} ``` --- Scale the length of the arrows by the $y$ coordinate: ```wl In[1]:= StreamPlot[{Sin[x], Cos[y]}, {x, -Pi, Pi}, {y, -Pi, Pi}, StreamScale -> {Automatic, 2, Automatic, Function[{x, y, vx, vy, n}, y]}] Out[1]= [image] ``` #### StreamStyle (5) ``StreamColorFunction`` has precedence over colors specified in ``StreamStyle`` : ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamStyle -> Orange] Out[1]= [image] ``` --- Set ``StreamColorFunction -> None`` to specify colors with ``StreamStyle`` : ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamStyle -> Orange, StreamColorFunction -> None] Out[1]= [image] ``` --- Apply a variety of styles to the streamlines: ```wl In[1]:= Table[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamScale -> Full, StreamStyle -> s, StreamColorFunction -> None], {s, {Orange, Thick, Directive[Orange, Dashed]}}] Out[1]= {[image], [image], [image]} ``` --- Specify a custom arrowhead: ```wl In[1]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamScale -> Full, StreamStyle -> Arrowheads[{{0.03, Automatic, Graphics[Circle[]]}}]] Out[1]= [image] ``` --- Set the style for multiple vector fields: ```wl In[1]:= StreamPlot[{{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {-(1 + x - y ^ 2), -1 - x ^ 2 + y}}, {x, -3, 3}, {y, -3, 3}, StreamPoints -> 30, StreamStyle -> {Red, Blue}, StreamColorFunction -> None] Out[1]= [image] ``` ### Applications (16) Streamlines for the gradient field of $\sin (x,y)$ over the unit square: ```wl In[1]:= StreamPlot[Evaluate[D[Sin[x y], {{x, y}}]], {x, 0, 1}, {y, 0, 1}, StreamScale -> Large] Out[1]= [image] ``` --- Streamlines for the Hamiltonian vector field of $\sin (x y)$ : ```wl In[1]:= StreamPlot[Evaluate@{D[Sin[x y], {y}], -D[Sin[x y], {x}]}, {x, 0, 2Pi}, {y, 0, 2Pi}, StreamScale -> Large] Out[1]= [image] ``` --- Global attractor of damped conservative system: ```wl In[1]:= StreamPlot[{y, -y + x - x ^ 3}, {x, -3, 3}, {y, -3, 3}, StreamScale -> Large] Out[1]= [image] ``` --- Combine several examples into a tabbed view: ```wl In[1]:= fields = | | | | ---------------------------- | --------------------------------------------------- | | "positive invariant set" | {y, -x + y(1 - x ^ 2 - 2y ^ 2)} | | "structurally stable system" | {2x + y - x(x ^ 2 + y ^ 2), -y - y(x ^ 2 + y ^ 2)} | | "transcritical bifurcation" | {x ^ 2, -y} | | "reaction-diffusion" | {2(y - x) + x(1 - x ^ 2), -2(y - x) + y(1 - y ^ 2)} | | "Duffing's equation" | {y, x - x ^ 3} |; In[2]:= fieldIcon[f_] := Image[StreamPlot[f, {x, -3, 3}, {y, -3, 3}, Axes -> False, Frame -> False, StreamPoints -> 20, StreamStyle -> Thick], ImageSize -> 40] ``` Mouse over the tabs to get a description of the vector field: ```wl In[3]:= TabView[Table[Tooltip[fieldIcon[f[[2]]], f[[1]]] -> StreamPlot[f[[2]], {x, -3, 3}, {y, -3, 3}, StreamScale -> 0.2, PlotLabel -> TraditionalForm[Column@f[[2]]]], {f, fields}]] Out[3]= TabView[{{1, Tooltip[ErrorBox["[image]"], "positive invariant set", TooltipStyle -> "TextStyling"] -> ErrorBox["[image]"]}, {2, Tooltip[ErrorBox["[image]"], "structurally stable system", TooltipStyle -> "TextStyling"] -> ErrorBox["[im ... ge]"]}, {4, Tooltip[ErrorBox["[image]"], "reaction-diffusion", TooltipStyle -> "TextStyling"] -> ErrorBox["[image]"]}, {5, Tooltip[ErrorBox["[image]"], "Duffing's equation", TooltipStyle -> "TextStyling"] -> ErrorBox["[image]"]}}, 1] ``` --- Quadratic system with two limit cycles: ```wl In[1]:= p[x_, y_] := 169(x - 1) ^ 2 - 16(y - 1) ^ 2 - 153; q[x_, y_] := 144(x - 1) ^ 2 - 9(y - 1) ^ 2 - 135; In[2]:= With[{λ = 0.8}, StreamPlot[Evaluate@{p[x, y]Cos[λ] - q[x, y]Sin[λ], p[x, y]Sin[λ] + q[x, y]Cos[λ]}, {x, -1, 3}, {y, -1, 3}, StreamScale -> Large, PlotLabel -> Row[{"λ = ", λ}]]] Out[2]= [image] ``` --- Van der Pol oscillator: ```wl In[1]:= Table[StreamPlot[{y, -x + λ(1 - x ^ 2)y}, {x, -3, 3}, {y, -3, 3}, PlotLabel -> Row[{"λ = ", λ}], StreamScale -> Large], {λ, {-1, 0, 1, 5}}] Out[1]= [image] ``` --- Characterize linear planar systems interactively: ```wl In[1]:= Manipulate[Row[{Text["m"] == MatrixForm[m], StreamPlot[Evaluate[m.{x, y}], {x, -1, 1}, {y, -1, 1}, StreamScale -> Large, ImageSize -> Small]}], {{m, (| | | | - | - | | 1 | 0 | | 0 | 2 |)}, {(| | | | - | - | | 1 | 0 | | 0 | 2 |) -> "Nodal source", (| | | | - | - | | 1 | 1 | | 0 | 1 |) -> "Degenerate source", (| | | | -- | - | | 0 | 1 | | -1 | 1 |) -> "Spiral source", (| | | | -- | -- | | -1 | 0 | | 0 | -2 |) -> "Nodal sink", (| | | | -- | -- | | -1 | 1 | | 0 | -1 |) -> "Degenerate sink", (| | | | -- | -- | | 0 | 1 | | -1 | -1 |) -> "Spiral sink", (| | | | -- | - | | 0 | 1 | | -1 | 0 |) -> "Center", (| | | | - | -- | | 1 | 0 | | 0 | -2 |) -> "Saddle"}}] Out[1]= DynamicModule[«8»] ``` --- Use a stream plot as a background for an interactive differential equation solution plotter: ```wl In[1]:= Manipulate[ splot = StreamPlot[{y, -Sin[x] - .25 y}, {x, -4, 4}, {y, -3, 3}]; Dynamic[Show[splot, ParametricPlot[Evaluate[First[{x[t], y[t]} /. NDSolve[{x'[t] == y[t], y'[t] == -Sin[x[t]] - .25y[t], Thread[{x[0], y[0]} == point]}, {x, y}, {t, 0, T}]]], {t, 0, T}, PlotStyle -> Red]]], {{T, 10}, 1, 100}, {{point, {1, 0}}, Locator}] Out[1]= DynamicModule[«8»] ``` --- Unfolding a double zero eigenvalue: ```wl In[1]:= f1[x_, y_] := {y, λ1 + λ2 x + y ^ 2 + x y}; In[2]:= Grid@Table[StreamPlot[Evaluate@f1[x, y], {x, -3, 3}, {y, -3, 3}, StreamScale -> Large, PlotLabel -> Row[{"λ1 = ", λ1, " λ2 = ", λ2}]], {λ1, {-1, 0, 1}}, {λ2, {-1, 0, 1}}] Out[2]= | | | | | ------- | ------- | ------- | | [image] | [image] | [image] | | [image] | [image] | [image] | | [image] | [image] | [image] | ``` --- Rotating pendulum: ```wl In[1]:= Manipulate[StreamPlot[{y, (Cos[x] - λ)Sin[x]}, {x, -3, 3}, {y, -3, 3}, StreamScale -> Large, PlotLabel -> Row[{"λ = ", λ}]], {λ, -5, 5}] Out[1]= DynamicModule[«8»] ``` --- A two-parameter potential: ```wl In[1]:= Manipulate[StreamPlot[{y, -λ - μ x + x ^ 3}, {x, -3, 3}, {y, -3, 3}, StreamScale -> Large, PlotLabel -> Row[{"λ = ", λ, " , μ = ", μ}]], {λ, -1, 1}, {μ, -1, 1}] Out[1]= DynamicModule[«8»] ``` --- Generate a list of rasterized stream plots for animation: ```wl In[1]:= labeledImage[g_, λ_] := Row[{Image[g, ImageSize -> 175], Row[{" λ = ", λ}]}] In[2]:= options = {StreamScale -> Large, StreamStyle -> "BackwardPointer"}; In[3]:= g = Table[labeledImage[StreamPlot[{-(x Sin[λ] + y Cos[λ]) + (1 - x ^ 2 - y ^ 2) ^ 2(x Cos[λ] - y Sin[λ]), (x Cos[λ] - y Sin[λ]) + (1 - x ^ 2 - y ^ 2) ^ 2(x Sin[λ] + y Cos[λ])}, {x, -3, 3}, {y, -3, 3}, Evaluate@options], λ], {λ, 0, 2π, π / 16}]; ``` Animating a list of rasters instead of the original vector graphics may reduce memory usage: ```wl In[4]:= ListAnimate[g] Out[4]= DynamicModule[«8»] ``` --- Create an animation that shifts the streamline colors in the direction of the vector norms: ```wl In[1]:= frames = Table[Image[StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamScale -> 0.06, StreamColorFunction -> (Hue[k + #5]&)], ImageSize -> 175], {k, 0, 1, 0.1}]; In[2]:= ListAnimate[frames] Out[2]= DynamicModule[«8»] ``` --- Explore various streamline styles and scales with several examples: ```wl In[1]:= fields = {{x + y ^ 2 + y ^ 3, -x + y + y x ^ 2}, {x - x y ^ 2 + y ^ 3, 3y - y x ^ 2 + x ^ 3}, {(2 - x - 2y)x, (2 - 2x - y)y}, {y, (1 - x ^ 2 - y ^ 2)y / 20 - x}, {2 x y, 1 + x ^ 2 - y ^ 2}, {y, x - x ^ 2 + (1 + x)y}}; In[2]:= styles = {"Arrow", "ArrowArrow", "CircleArrow", "BarDot", "Dot", "DotDot", "DotArrow", "Dart", "Drop", "BackwardPointer", "Pointer", "Toothpick", "Dart", "PinDart", "DoubleDart", "Segment", "Line"}; ``` Generate icons to graphically represent field choices: ```wl In[3]:= icons = Table[f -> Image[StreamPlot[f, {x, -3, 3}, {y, -3, 3}, Axes -> False, Frame -> False, StreamPoints -> 20, StreamStyle -> "Line"], ImageSize -> 42], {f, fields}]; ``` Click on the field icons to switch field plots: ```wl In[4]:= Manipulate[StreamPlot[field, {x, -3, 3}, {y, -3, 3}, ImageSize -> 300, StreamStyle -> style, StreamScale -> scale, StreamColorFunction -> color], {style, styles}, {color, ColorData["Gradients"]}, {{scale, 0.2}, 0.05, 0.5, 0.05}, {{field, icons[[1, 1]]}, icons, Setter}] Out[4]= DynamicModule[«8»] ``` --- Generate a list of stream plots of varying $\lambda$ : ```wl In[1]:= values = {-1, 0, 1};plots = MapIndexed[Function[{λ, i}, StreamPlot[{y, λ - x ^ 2}, {x, -3, 3}, {y, -3, 3}, StreamPoints -> 16, StreamScale -> 0.07, StreamColorFunction -> None, StreamStyle -> ColorData["SolarColors"][0.3i[[1]]]]], values] Out[1]= [image] ``` Stack 2D stream plots in 3D: ```wl In[2]:= stackPlots[plots2D : {__Graphics}, dh_, o : OptionsPattern[Graphics3D]] := Graphics3D[MapIndexed[Function[{g, index}, g[[1]] /. Arrow[v2d_] :> Arrow[v2d /. {x_ ? NumericQ, y_ ? NumericQ} :> {x, y, dh index[[1]]}]], plots2D], o] In[3]:= plotSpacing = 5; stackPlots[plots, plotSpacing, Axes -> True, Boxed -> False, Ticks -> {Automatic, Automatic, MapIndexed[{plotSpacing#2[[1]], Row[{"λ = ", #1}]}&, values]}] Out[3]= [image] ``` --- Specify the geometry for a fluid flow: ```wl In[1]:= Ω = RegionUnion[Rectangle[{0, 0.01}, {0.02, 0.02}], Rectangle[{0.02, 0}, {0.08, 0.03}], Rectangle[{0.08, 0}, {0.1, 0.01}], Rectangle[{0.08, .02}, {0.1, 0.03}]]; RegionPlot[Ω, AspectRatio -> Automatic] Out[1]= [image] ``` Specify the boundary conditions for a flow that enters at the left-hand channel and exits through the two right-hand channels: ```wl In[2]:= inflowBC = DirichletCondition[{u[x, y] == 4000(y - 0.01)(0.02 - y), v[x, y] == 0}, x == 0];outflowBC = DirichletCondition[p[x, y] == 0, x == 0.1];wallBC = DirichletCondition[{u[x, y] == 0, v[x, y] == 0}, 0 < x < 0.1];bcs = {inflowBC, outflowBC, wallBC}; ``` Define the Navier–Stokes equations: ```wl In[3]:= navierstokes = { Inactive[Div][(-μ Inactive[Grad][u[x, y], {x, y}]), {x, y}] + ρ {u[x, y], v[x, y]}.Inactive[Grad][u[x, y], {x, y}] + p^(1, 0)[x, y] == 0, Inactive[Div][(-μ Inactive[Grad][v[x, y], {x, y}]), {x, y}] + ρ {u[x, y], v[x, y]}.Inactive[Grad][v[x, y], {x, y}] + p^(0, 1)[x, y] == 0, u^(1, 0)[x, y] + v^(0, 1)[x, y] == 0} /. {ρ -> 1, μ -> 2 10^-5}; ``` Use the finite element method to solve for the steady flow velocities and pressure: ```wl In[4]:= {uVel, vVel, pressure} = NDSolveValue[{navierstokes, bcs}, {u, v, p}, {x, y}∈Ω, Method -> {"FiniteElement", "InterpolationOrder" -> {u -> 2, v -> 2, p -> 1}, "MeshOptions" -> {"MaxCellMeasure" -> 0.00000025}}]; ``` Use ``DensityPlot`` to plot the pressure and ``StreamPlot`` to plot the flow: ```wl In[5]:= Show[ DensityPlot[pressure[x, y], {x, y}∈uVel["ElementMesh"], PlotRange -> All, Frame -> None, Axes -> None, AspectRatio -> Automatic, ColorFunction -> "DeepSeaColors", PlotLegends -> Placed[BarLegend[Automatic, LegendLabel -> Placed["pressure", Above]], Above]], StreamPlot[{uVel[x, y], vVel[x, y]}, {x, y}∈Ω, AspectRatio -> Automatic, StreamColorFunction -> "SolarColors", PlotLegends -> BarLegend[Automatic, LegendLabel -> Placed["speed", Below]], StreamPoints -> Fine], ImageSize -> Medium ] Out[5]= [image] ``` ### Properties & Relations (11) Use ``ListStreamPlot`` for plotting data: ```wl In[1]:= data = Table[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3, 0.2}, {y, -3, 3, 0.2}]; In[2]:= ListStreamPlot[data] Out[2]= [image] ``` --- Use ``VectorPlot`` to plot with vectors instead of streamlines: ```wl In[1]:= VectorPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}] Out[1]= [image] ``` Use ``ListVectorPlot`` to generate a plot based on data: ```wl In[2]:= data = Table[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3, 0.1}, {y, -3, 3, 0.1}]; In[3]:= ListVectorPlot[data] Out[3]= [image] ``` --- Use ``StreamPlot3D`` to plot streamlines of 3D vector fields: ```wl In[1]:= StreamPlot3D[{z, -x, y}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}] Out[1]= [image] ``` Use ``ListStreamPlot3D`` to plot streamlines based on data: ```wl In[2]:= data = Table[{z, -x, y}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}]; In[3]:= ListStreamPlot3D[data] Out[3]= [image] ``` --- Use ``StreamDensityPlot`` to add a density plot of the scalar field: ```wl In[1]:= StreamDensityPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}] Out[1]= [image] ``` Use ``VectorDensityPlot`` to plot vectors instead of streamlines: ```wl In[2]:= VectorDensityPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}] Out[2]= [image] ``` Use ``ListStreamDensityPlot`` to generate a plot based on data: ```wl In[3]:= data = Table[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3, 0.1}, {y, -3, 3, 0.1}]; In[4]:= ListStreamDensityPlot[data] Out[4]= [image] ``` Use ``ListVectorDensityPlot`` to plot arrows instead of streamlines: ```wl In[5]:= ListVectorDensityPlot[data] Out[5]= [image] ``` --- Use ``LineIntegralConvolutionPlot`` to plot the line integral convolution of a vector field: ```wl In[1]:= LineIntegralConvolutionPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}] Out[1]= [image] ``` --- Use ``VectorDisplacementPlot`` to visualize the deformation of a region associated with a displacement vector field: ```wl In[1]:= VectorDisplacementPlot[{y, x - x^3}, {x, y}∈Disk[], VectorPoints -> Automatic] Out[1]= [image] ``` Use ``ListVectorDisplacementPlot`` to visualize the same deformation based on data: ```wl In[2]:= data = Table[{{x, y} = RandomReal[{-1, 1}, {2}], {y, x - x ^ 3}}, {300}]; In[3]:= ListVectorDisplacementPlot[data, Disk[], VectorPoints -> Automatic] Out[3]= [image] ``` --- Use ``VectorPlot3D`` to visualize 3D vector fields: ```wl In[1]:= VectorPlot3D[{x, y, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}] Out[1]= [image] ``` Use ``ListVectorPlot3D`` to generate a plot based on data: ```wl In[2]:= data = Table[{x, y, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]; In[3]:= ListVectorPlot3D[data] Out[3]= [image] ``` --- Plot vectors on surfaces with ``SliceVectorPlot3D`` : ```wl In[1]:= SliceVectorPlot3D[{-y, x, z}, "CenterSphere", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}] Out[1]= [image] ``` Plot vectors based on data: ```wl In[2]:= data = Table[{-y, x, z}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}]; In[3]:= ListSliceVectorPlot3D[data, "CenterSphere"] Out[3]= [image] ``` --- Use ``VectorDisplacementPlot3D`` to visualize the deformation of a 3D region associated with a displacement vector field: ```wl In[1]:= VectorDisplacementPlot3D[{y, x, -z}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, VectorPoints -> "Boundary"] Out[1]= [image] ``` Use ``ListVectorDisplacementPlot3D`` to visualize the same deformation based on data: ```wl In[2]:= data = Table[{{x, y, z} = RandomReal[{0, 1}, {3}], {y, x, -z}}, {300}]; In[3]:= ListVectorDisplacementPlot3D[data, Cuboid[], VectorPoints -> "Boundary"] Out[3]= [image] ``` --- Plot a complex function as a vector field using streamlines: ```wl In[1]:= ComplexStreamPlot[z^2, {z, 2}] Out[1]= [image] ``` Use vectors instead of streamlines: ```wl In[2]:= ComplexVectorPlot[z^2, {z, 2}] Out[2]= [image] ``` --- Use ``GeoVectorPlot`` to plot vectors on a map: ```wl In[1]:= GeoVectorPlot[GeoVector[GeoPosition[CompressedData["«6488»"]] -> {{0.5706379232485146, Quantity[354.01686143622794, "AngularDegrees"]}, {0.48751317221734114, Quantity[327.18610724051325, "AngularDegrees"]}, {0.42407845478418604, Quantity[199.859344783 ... 904, "AngularDegrees"]}, {0.9366099079317551, Quantity[357.70482317743733, "AngularDegrees"]}, {0.8256817194791912, Quantity[242.07227508889662, "AngularDegrees"]}, {0.2661401145642981, Quantity[152.90003252279325, "AngularDegrees"]}}]] Out[1]= [image] ``` Use ``GeoStreamPlot`` to plot streamlines instead of vectors: ```wl In[2]:= GeoStreamPlot[GeoVector[GeoPosition[CompressedData["«6488»"]] -> {{0.5706379232485146, Quantity[354.01686143622794, "AngularDegrees"]}, {0.48751317221734114, Quantity[327.18610724051325, "AngularDegrees"]}, {0.42407845478418604, Quantity[199.859344783 ... 904, "AngularDegrees"]}, {0.9366099079317551, Quantity[357.70482317743733, "AngularDegrees"]}, {0.8256817194791912, Quantity[242.07227508889662, "AngularDegrees"]}, {0.2661401145642981, Quantity[152.90003252279325, "AngularDegrees"]}}]] Out[2]= [image] ``` ## See Also * [`VectorPlot`](https://reference.wolfram.com/language/ref/VectorPlot.en.md) * [`StreamPlot3D`](https://reference.wolfram.com/language/ref/StreamPlot3D.en.md) * [`StreamDensityPlot`](https://reference.wolfram.com/language/ref/StreamDensityPlot.en.md) * [`ListStreamPlot`](https://reference.wolfram.com/language/ref/ListStreamPlot.en.md) * [`LineIntegralConvolutionPlot`](https://reference.wolfram.com/language/ref/LineIntegralConvolutionPlot.en.md) * [`ParametricPlot`](https://reference.wolfram.com/language/ref/ParametricPlot.en.md) * [`ContourPlot`](https://reference.wolfram.com/language/ref/ContourPlot.en.md) * [`DensityPlot`](https://reference.wolfram.com/language/ref/DensityPlot.en.md) * [`Plot3D`](https://reference.wolfram.com/language/ref/Plot3D.en.md) * [`VectorPlot3D`](https://reference.wolfram.com/language/ref/VectorPlot3D.en.md) * [`SliceVectorPlot3D`](https://reference.wolfram.com/language/ref/SliceVectorPlot3D.en.md) ## Related Guides * [Vector Visualization](https://reference.wolfram.com/language/guide/VectorVisualization.en.md) * [Function Visualization](https://reference.wolfram.com/language/guide/FunctionVisualization.en.md) * [Vector Analysis](https://reference.wolfram.com/language/guide/VectorAnalysis.en.md) * [Differential Equations](https://reference.wolfram.com/language/guide/DifferentialEquations.en.md) * [Solvers over Regions](https://reference.wolfram.com/language/guide/GeometricSolvers.en.md) ## History * [Introduced in 2008 (7.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn70.en.md) \| [Updated in 2012 (9.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn90.en.md) ▪ [2014 (10.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn100.en.md) ▪ [2018 (11.3)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn113.en.md) ▪ [2020 (12.1)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn121.en.md) ▪ [2020 (12.2)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn122.en.md) ▪ [2021 (13.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn130.en.md) ▪ [2022 (13.1)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn131.en.md)