Wolfram Language & System Documentation Center

RandomPoint

RandomPoint[reg]

gives a pseudorandom point uniformly distributed in the region reg.

RandomPoint[reg,n]

gives a list of n pseudorandom points uniformly distributed in the region reg.

RandomPoint[reg,{n₁,n₂,…}]

gives an n₁× n₂×… array of pseudorandom points.

RandomPoint[reg,…,{{x_min,x_max},…}]

restricts to the bounds .

Details and Options

RandomPoint can generate random points for any RegionQ region that is also ConstantRegionQ.
RandomPoint will generate points uniformly in the region reg.
RandomPoint gives a different sequence of pseudorandom numbers whenever you run the Wolfram Language. You can start with a particular seed using SeedRandom.
With the setting WorkingPrecision->p, random numbers of precision p will be generated.

Examples

open all close all

Basic Examples (3)

Generate a list of points in a unit disk:

Wolfram Language code: pts = RandomPoint[Disk[], 5000];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

Generate multiple lists of points on a unit circle:

Wolfram Language code: pl = RandomPoint[Circle[], {3, 100}];

Wolfram Language code: Table[Graphics[Point[pts]], {pts, pl}]

Generate a list of points in a standard cylinder:

Wolfram Language code: pts = RandomPoint[Cylinder[], 10 ^ 4];

Wolfram Language code: Graphics3D[{PointSize[Tiny], Point[pts]}, Boxed -> False]

Scope (22)

Basic Uses (5)

Generate a point in a unit ball region:

Wolfram Language code: ℛ = Ball[];

Wolfram Language code: pt = RandomPoint[ℛ]

Wolfram Language code: RegionMember[ℛ, pt]

Generate a list of points for a triangle region:

Wolfram Language code: ℛ = Triangle[{{0, 0}, {1, 1}, {2, 0}}];

Wolfram Language code: pts = RandomPoint[ℛ, 1000];

Wolfram Language code: Graphics[{ℛ, Red, PointSize[Tiny], Point[pts]}]

Generate multiple lists of points for a unit disk region:

Wolfram Language code: ℛ = Disk[];

Wolfram Language code: pl = RandomPoint[ℛ, {3, 20}];

Wolfram Language code: Table[Graphics[{ℛ, Red, Point[pts]}], {pts, pl}]

Generate points on an unbounded region within given bounds:

Wolfram Language code: ℛ = HalfPlane[{{0, 0}, {1, 1}}, {0, 1}];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 4, {{0, 1}, {0, 1}}];

The random points are restricted to :

Wolfram Language code: Graphics[{LightBlue, ℛ, Red, PointSize[Tiny], Point[pts]}, Frame -> True, PlotRangePadding -> 0.1]

Generate points on an unbounded region within given bounds in :

Wolfram Language code: ℛ = ConicHullRegion[{{0, 0, 0}}, {{-1, 1, 1}, {1, 1, 1}, {-1, 1, 0}, {1, 1, 0}}];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 4, {{-1, 1}, {-1, 1}, {-1, 1}}];

Wolfram Language code:

Graphics3D[{{Opacity[0.5], ℛ}, {Blue, PointSize[Tiny], Point[pts]}}, Axes -> True, PlotRange -> {{-2, 2}, {0, 2}, {-1, 2}}]

Special Regions (6)

Regions in :

Wolfram Language code: RandomPoint[Point[{{1}, {2}, {3}}]]

Wolfram Language code: RandomPoint[Interval[{1, 5}], 5]

Regions in :

Wolfram Language code: RandomPoint[Point[{{1, 1}, {2, 2}, {3, 3}}]]

Wolfram Language code: RandomPoint[Line[{{0, 0}, {1, 1}}]]

Wolfram Language code: RandomPoint[Disk[{1, 2}, {3, 4}]]

Visualize region points in :

Wolfram Language code: pts = RandomPoint[Circle[], 300];

Wolfram Language code: Graphics[Point[pts]]

Regions in :

Wolfram Language code: RandomPoint[Point[{{1, 1, 1}, {2, 2, 2}, {3, 3, 3}}]]

Wolfram Language code: RandomPoint[Line[{{1, 2, 3}, {4, 5, 6}}]]

Wolfram Language code: RandomPoint[Polygon[{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}]]

Wolfram Language code: RandomPoint[Cone[{{0, 0, 0}, {1, 1, 1}}, 1 / 2]]

Visualize region points in :

Wolfram Language code: ℛ = Tetrahedron[];

Wolfram Language code: pts = RandomPoint[ℛ, 300];

Wolfram Language code: Graphics3D[{{Opacity[0.2], ℛ}, {Green, Sphere[pts, 0.02]}}, Boxed -> False]

Regions in :

Wolfram Language code: RandomPoint[Point[{{1, 1, 1, 1}, {2, 2, 2, 2}, {3, 3, 3, 3}}]]

Wolfram Language code: RandomPoint[Simplex[{{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}}]]

Wolfram Language code: RandomPoint[Cuboid[{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}]]

Wolfram Language code: RandomPoint[Ball[{0, 0, 0, 0, 0, 0, 0}, 8]]

Formula Regions (3)

Implicit regions:

Wolfram Language code: RandomPoint[ImplicitRegion[x^2 + y^2 ≤ 1, {x, y}]]

Wolfram Language code: RandomPoint[ImplicitRegion[x^2 + y^2 ≤ 1, {x, y, {z, 0, 2}}]]

Visualize region points in :

Wolfram Language code: ℛ = ImplicitRegion[x ^ 2 - 2y ^ 2 <= 1, {{x, -3, 3}, {y, -4, 4}}];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 4, {{-3, 3}, {-4, 4}}];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

Parametric regions:

Wolfram Language code: ℛ = ParametricRegion[{{s, (1 + t) s ^ 2 - t}, -1 ≤ s ≤ 1 && 0 ≤ t ≤ 1}, {s, t}];

Wolfram Language code: pts = RandomPoint[ℛ, 5000];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

Mesh Regions (4)

MeshRegion in 2D:

Wolfram Language code: ℛ = DelaunayMesh[RandomReal[8, {50, 2}]];

Wolfram Language code: pts = RandomPoint[ℛ, 2000];

Wolfram Language code: Show[ℛ, Graphics[{Red, PointSize[Tiny], Point[pts]}]]

In 3D:

Wolfram Language code: ℛ = DelaunayMesh[RandomReal[8, {50, 3}]];

Wolfram Language code: pts = RandomPoint[ℛ, 200];

Wolfram Language code: Show[HighlightMesh[RegionBoundary[ℛ], Style[2, Opacity[0.1]]], Graphics3D[{Green, Sphere[pts, 0.2]}]]

BoundaryMeshRegion in 2D:

Wolfram Language code: ℛ = ConvexHullMesh[RandomReal[8, {50, 2}]];

Wolfram Language code: pts = RandomPoint[ℛ, 2000];

Wolfram Language code: Show[ℛ, Graphics[{Red, PointSize[Tiny], Point[pts]}]]

BoundaryMeshRegion in 3D:

Wolfram Language code: ℛ = ConvexHullMesh[RandomReal[8, {50, 3}]];

Wolfram Language code: pts = RandomPoint[ℛ, 200];

Wolfram Language code: Show[HighlightMesh[RegionBoundary[ℛ], Style[2, Opacity[0.1]]], Graphics3D[{Green, Sphere[pts, 0.2]}]]

Derived Regions (4)

RegionIntersection of two regions:

Wolfram Language code: ℛ = RegionIntersection[Disk[{0, 0}, 1], Disk[{0, 1}, 1]];

Wolfram Language code: pts = RandomPoint[ℛ, 5000];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

RegionUnion of mixed-dimensional regions:

Wolfram Language code: ℛ = RegionUnion[Circle[{1, 0}, 1], Disk[{0, 0}, 1]];

Wolfram Language code: DiscretizeRegion[ℛ]

Points are generated for the maximum dimensional component:

Wolfram Language code: pts = RandomPoint[ℛ, 5000];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

TransformedRegion:

Wolfram Language code: ℛ = TransformedRegion[Disk[{0, 0}, 1], ShearingTransform[Pi / 4, {1, 0}, {0, 1}]];

Wolfram Language code: pts = RandomPoint[ℛ, 3000];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

RegionBoundary:

Wolfram Language code:

ℛ = RegionBoundary[Disk[{0, 0}, 1]];
DiscretizeRegion[ℛ]

Wolfram Language code: pts = RandomPoint[ℛ, 100];

Wolfram Language code: Graphics[Point[pts]]

Applications (24)

2D Galleries (9)

Generate a list of uniform random unit vectors in :

Wolfram Language code: v = RandomPoint[Sphere[{0, 0}, 1], 200];

Wolfram Language code: Graphics[Table[Arrow[{{0, 0}, p}], {p, v}]]

Visualize a parametric heart curve:

Wolfram Language code:

ℛ = ParametricRegion[
	{(4 Sin[t] ^ 3) / 5, 1 / 20 (13 Cos[t] - 5 Cos[2 t] - 2 Cos[3 t] - Cos[4 t])}, {{t, 0, 2 π}}];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 3, {{-1, 1}, {-1, 1}}];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

Parametric butterfly curve:

Wolfram Language code:

ℛ = ParametricRegion[{1 / 5 (E ^ Cos[t] - 2 Cos[4 t] + Sin[t / 12] ^ 5) Sin[t], 1 / 5 Cos[t] (E ^ Cos[t] - 2 Cos[4 t] + Sin[t / 12] ^ 5) - 1 / 6}, {{t, 0, 100}}];

Wolfram Language code: pts = RandomPoint[ℛ, 5000, {{-1, 1}, {-1, 1}}];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

Implicit trifolium curve:

Wolfram Language code: ℛ = ImplicitRegion[x ^ 3 - 3 x y ^ 2 + (x ^ 2 + y ^ 2) ^ 2 == 0, {x, y}];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 3, {{-1, 1}, {-1, 1}}];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

Graphics scene:

Wolfram Language code:

p = RandomReal[1, {20, 2}];
g = Graphics[{BSplineCurve[p], Line[p]}];

Wolfram Language code: pts = RandomPoint[DiscretizeGraphics[g], 10 ^ 4];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

Implicit Lissajous region:

Wolfram Language code: ℛ = ImplicitRegion[-1 + (-1 + 18 x^2 - 48 x^4 + 32 x^6)^2 + (-1 + 18 y^2 - 48 y^4 + 32 y^6)^2 ≤ 0, {x, y}];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 4];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

Mixed implicit and parametric region:

Wolfram Language code: ℛ = ParametricRegion[{{s, s t}, s ^ 2 + t ^ 2 ≤ 1}, {s, t}];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 4];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

Country polygon:

Wolfram Language code: CountryData["Austria", "Polygon"]

Wolfram Language code: ℛ = DiscretizeRegion[CountryData["Austria", "Polygon"]];

Wolfram Language code: pts = RandomPoint[ℛ, 5000];

Wolfram Language code: Graphics3D[{PointSize[Tiny], Point[pts]}]

Text primitive:

Wolfram Language code: t = Text[Style["π", Bold]];

Wolfram Language code: mr = DiscretizeGraphics[t, _Text, MaxCellMeasure -> 0.1];

Wolfram Language code: pts = RandomPoint[mr, 3000];

Wolfram Language code: Graphics[{PointSize[Tiny], Point[pts]}]

3D Galleries (6)

Generate a list of uniform random unit vectors in :

Wolfram Language code: v = RandomPoint[Sphere[{0, 0, 0}, 1], 200];

Wolfram Language code: Graphics3D[Table[Arrow[{{0, 0, 0}, p}], {p, v}], Boxed -> False]

Parametric helix curve:

Wolfram Language code: ℛ = ParametricRegion[{Cos[t], Sin[t], t / 16}, {{t, 0, 9π}}];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 3, {{-1, 1}, {-1, 1}, {0, 2}}];

Wolfram Language code: Graphics3D[{PointSize[Tiny], Point[pts]}, Boxed -> False]

Implicit Viviani's curve:

Wolfram Language code: ℛ = ImplicitRegion[(-1 + x)^2 + y^2 == 1 && x^2 + y^2 + z^2 == 4, {x, y, z}];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 3];

Wolfram Language code: Graphics3D[{PointSize[Tiny], Point[pts]}, Boxed -> False]

Parametric torus surface:

Wolfram Language code: ℛ = ParametricRegion[{(3 + Cos[v])Cos[u], (3 + Cos[v])Sin[u], Sin[v]}, {{u, 0, 2Pi}, {v, 0, 2Pi}}];

Wolfram Language code: pts = RandomPoint[ℛ, 4000, {{-4, 4}, {-4, 4}, {-1, 1}}];

Wolfram Language code: Graphics3D[{PointSize[Tiny], Point[pts]}, Boxed -> False]

Implicit eight solid:

Wolfram Language code: ℛ = ImplicitRegion[4 z ^ 4 + 9 (x ^ 2 + y ^ 2 - 4 z ^ 2) ≤ 1, {x, y, z}];

Wolfram Language code: pts = RandomPoint[ℛ, 4000];

Wolfram Language code: Graphics3D[{PointSize[Tiny], Point[pts]}, Boxed -> False]

Graphics3D scene:

Wolfram Language code:

p = Table[{i, j, RandomReal[{-1, 1}]}, {i, 5}, {j, 5}];
g = Graphics3D[{BSplineSurface[p], Sphere[#, 0.1]& /@ p}];

Wolfram Language code: pts = RandomPoint[DiscretizeGraphics[g], 5000];

Wolfram Language code: Graphics3D[{PointSize[Tiny], Point[pts]}, Boxed -> False]

Monte Carlo Methods (2)

Perform Monte Carlo integration to estimate the area of a unit disk:

Wolfram Language code:

ℛ = Disk[{0, 0}, 1];
Graphics[{LightBlue, EdgeForm[Gray], ℛ}]

Get the region bounds:

Wolfram Language code: boundingBox = Cuboid@@Transpose[RegionBounds[ℛ]]

Uniformly sample over the bounding box of the region:

Wolfram Language code: pts = RandomPoint[boundingBox, 10 ^ 4];

Wolfram Language code:

col = RegionMember[ℛ, pts] /. {False -> Gray, True -> Red};
Graphics[{ℛ, PointSize[Tiny], {col, Point /@ pts}}]

Count the number of samples inside the region:

Wolfram Language code: inside = Count[RegionMember[ℛ, pts], True]

Get the ratio of samples inside the region to the total number of sample points:

Wolfram Language code: ratio = N[(inside/Length[pts])]

Get the bounding area:

Wolfram Language code: area = Area[boundingBox]

Get the approximate area of the region:

Wolfram Language code: area * ratio

Visualize the Minkowski sum (orange) of two regions:

Wolfram Language code:

r1 = Annulus[{9, 0}, {3, 4}];
r2 = RegularPolygon[{0, 10}, 2, 3];

Wolfram Language code:

p1 = RandomPoint[r1, 10 ^ 5];
p2 = RandomPoint[r2, 10 ^ 5];

Sum of points from two regions gives points of the Minkowski sum region:

Wolfram Language code: msum = p1 + p2;

Wolfram Language code: Graphics[{{Blue, r1}, {Brown, r2}, {Orange, PointSize[Tiny], Point[msum]}}]

Region Relations (3)

Compute an approximate bounding box for a region from random samples. The resulting bounding will be a subset of the true bounding box:

Wolfram Language code: ℛ = Polygon[{{0, 0}, {2, -1}, {1, 0}, {2, 1}}];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 3];

Wolfram Language code: CoordinateBounds[pts]

Compare with its region bounds:

Wolfram Language code: RegionBounds[ℛ]

Show that a region is not a subset of another:

Wolfram Language code: {disk, square} = {Disk[{1, 1 / 2}, 1 / 2], Rectangle[]};

Wolfram Language code: g = Graphics[{Opacity[0.5], {Green, square}, {Blue, disk}}]

Check if any point from a set of random points in the disk are not in the square:

Wolfram Language code: mf = RegionMember[square];

Wolfram Language code: pts = RandomPoint[disk, 10 ^ 3];

Wolfram Language code: AllTrue[pts, mf]

Visualize the random points in the disk that are not in the square:

Wolfram Language code: Show[g, Graphics[{Red, PointSize[Tiny], Point[Select[pts, Not @* mf]]}]]

Determine that two regions are not equal:

Wolfram Language code: {disk, square} = {Disk[{1 / 2, 1 / 2}, 1 / 2], Rectangle[]};

Wolfram Language code: Graphics[{Opacity[0.5], {Green, square}, {Blue, disk}}]

Check if any point from a set of random points in the disk is not in the square, or vice versa:

Wolfram Language code: possibleSubregion[r1_, r2_] := AllTrue[RandomPoint[r1, 10 ^ 3], RegionMember[r2]];

Wolfram Language code: possibleSubregion[disk, square]

Wolfram Language code: possibleSubregion[square, disk]

Approximate Convexity (2)

Determine that a region is not convex by sampling, and show that there is a convex combination of the samples that is not a member of the original region:

Wolfram Language code: ℛ = Polygon[{{0, 0}, {2, -1}, {1, 0}, {2, 1}}];

Generate pairwise convex combinations of random points within the region:

Wolfram Language code: rp = RandomPoint[ℛ, 10];

Wolfram Language code: pairs = Line /@ Subsets[rp, {2}];

If a point on a pairwise convex combination is not in the region, then the region is not convex:

Wolfram Language code: AllTrue[pairs, AllTrue[RandomPoint[#, 10 ^ 2], RegionMember[ℛ]]&]

Wolfram Language code: Graphics[{ℛ, Red, pairs}]

Alternatively generate and test points in a convex hull of points:

Wolfram Language code: ch = ConvexHullMesh[RandomPoint[ℛ, 30]];

Wolfram Language code: AllTrue[RandomPoint[ch, 10 ^ 4], RegionMember[ℛ]]

Wolfram Language code: Show[{Graphics[{ℛ}], HighlightMesh[ch, Style[2, Opacity[0.5]]]}]

Compute the approximate convex hull of a region from random points within the region:

Wolfram Language code: ℛ = ImplicitRegion[x ^ 3 - 3x y ^ 2 + (x ^ 2 + y ^ 2) ^ 2 < 0, {x, y}];

Wolfram Language code: pts = RandomPoint[ℛ, 3000];

Wolfram Language code: cm = ConvexHullMesh[pts];

Wolfram Language code: Show[cm, Graphics[{Red, PointSize[Tiny], Point[pts]}]]

Nearest and Farthest Points (2)

Find an approximate nearest point in a region by sampling the region and computing the nearest point to the samples. This gives an upper bound for the distance to the region:

Wolfram Language code: ℛ = Triangle[{{0, 0}, {1, 1}, {2, 0}}];

Wolfram Language code: pt = {2, 1};

Find the nearest point from a set of random points in the region:

Wolfram Language code: rp = RandomPoint[ℛ, 10 ^ 3];

Wolfram Language code: np = First[Nearest[rp, pt]]

Wolfram Language code: Graphics[{LightGray, ℛ, Gray, Point[rp], PointSize[Medium], Blue, Point[pt], Red, Point[np], Dashed, Line[{pt, np}]}]

Compare the resulting distance to the true minimum distance to the region:

Wolfram Language code: apprDist = EuclideanDistance[pt, np]

Wolfram Language code: exactDist = RegionDistance[ℛ, pt]//N

Wolfram Language code: exactDist < apprDist

Define a function that finds an approximate farthest point in a region:

Wolfram Language code: approximateFarthest[reg_, pt_] := First[Nearest[RandomPoint[reg, 10 ^ 4], pt, DistanceFunction -> (-Norm[#1 - #2]&)]]

Find the farthest point on a region from a given point:

Wolfram Language code: ℛ = Triangle[{{0, 0}, {1, 1}, {2, 0}}];

Wolfram Language code: pt = {2, 1};

Wolfram Language code: fp = approximateFarthest[ℛ, {2, 1}]

Wolfram Language code: Graphics[{Point[pt], LightGray, ℛ, Red, Point[fp], Dashed, Line[{pt, fp}]}]

Properties & Relations (6)

RandomPoint will generate points with uniform density:

Wolfram Language code: ℛ = Disk[];

Wolfram Language code: pts = RandomPoint[ℛ, 10 ^ 5];

Wolfram Language code: Histogram3D[pts]

Choosing random coordinate points from a region of points:

Wolfram Language code: pts = RandomReal[1, {1000, 2}];

Wolfram Language code: ℛ = Point[pts];

Wolfram Language code: rp = RandomPoint[ℛ, 10 ^ 4];

Corresponds to RandomChoice of coordinate points:

Wolfram Language code: rc = RandomChoice[pts, 10 ^ 4];

Wolfram Language code: Histogram3D /@ {rp, rc}

Choosing random points from a Cuboid region:

Wolfram Language code: bounds = {{-1, 1}, {-1, 1}, {-1, 1}};

Wolfram Language code: ℛ = Cuboid@@Transpose[bounds];

Wolfram Language code: rp = RandomPoint[ℛ, 5000];

Corresponds to RandomVariate of a UniformDistribution:

Wolfram Language code: rv = RandomVariate[UniformDistribution[bounds], 5000];

Wolfram Language code: Table[Graphics3D[{PointSize[Tiny], Point[p]}, Boxed -> False], {p, {rp, rv}}]

Choosing random points from a Disk region:

Wolfram Language code: {a, r} = {1, 3};

Wolfram Language code: ℛ = Disk[{a, 0}, r];

Wolfram Language code: rp = RandomPoint[ℛ, 10 ^ 4];

Corresponds to RandomVariate of a WignerSemicircleDistribution:

Wolfram Language code: rv = RandomVariate[WignerSemicircleDistribution[a, r], 10 ^ 4];

Wolfram Language code: Histogram /@ {rp[[All, 1]], rv}

Choosing random coordinate points from a Triangle region:

Wolfram Language code: {min, max, mode} = {-1, 2, 1};

Wolfram Language code: ℛ = Triangle[{{min, 0}, {max, 0}, {mode, 1}}];

Wolfram Language code: rp = RandomPoint[ℛ, 10 ^ 4];

Corresponds to RandomVariate of a TriangularDistribution:

Wolfram Language code: rv = RandomVariate[TriangularDistribution[{min, max}, mode], 10 ^ 4];

Wolfram Language code: Histogram /@ {rp[[All, 1]], rv}

FindInstance can generate exact instances for special and formula regions:

Wolfram Language code: FindInstance[{x, y, z}∈Sphere[{1, 1, 1}, 1 / 2], {x, y, z}]

However, instances are not uniform:

Wolfram Language code: ℛ = ImplicitRegion[x^2 + y^2 ≤ 1, {x, y}];

Wolfram Language code: fi = {x, y} /. FindInstance[{x, y}∈ℛ, {x, y}, Reals, 10 ^ 3];

Wolfram Language code: rp = RandomPoint[ℛ, 10 ^ 3];

Wolfram Language code: Histogram3D /@ {fi, rp}

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

RandomPoint

Details and Options

Examples

Basic Examples (3)

Scope (22)

Basic Uses (5)

Special Regions (6)

Formula Regions (3)

Mesh Regions (4)

Derived Regions (4)

Applications (24)

2D Galleries (9)

3D Galleries (6)

Monte Carlo Methods (2)

Region Relations (3)

Approximate Convexity (2)

Nearest and Farthest Points (2)

Properties & Relations (6)

Text

CMS

APA

BibTeX

BibLaTeX

RandomPoint

Details and Options

Examples

Basic Examples (3)

Scope (22)

Basic Uses (5)

Special Regions (6)

Formula Regions (3)

Mesh Regions (4)

Derived Regions (4)

Applications (24)

2D Galleries (9)

3D Galleries (6)

Monte Carlo Methods (2)

Region Relations (3)

Approximate Convexity (2)

Nearest and Farthest Points (2)

Properties & Relations (6)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX