Total circles area: Difference between revisions
Added Algol 68
(Added Algol 68) |
|||
| (19 intermediate revisions by 8 users not shown) | |||
Line 113:
<pre>
Approximated area: 21.561559772
</pre>
=={{header|ALGOL 68}}==
{{Trans|Nim|which is a translation of Python}}
<syntaxhighlight lang="algol68">
BEGIN # caclulate an approximation to the total of some overlapping circles #
# translated from the Nim sample #
MODE CIRCLE = STRUCT( REAL x, y, r );
[]CIRCLE circles = ( ( 1.6417233788, 1.6121789534, 0.0848270516 )
, ( -1.4944608174, 1.2077959613, 1.1039549836 )
, ( 0.6110294452, -0.6907087527, 0.9089162485 )
, ( 0.3844862411, 0.2923344616, 0.2375743054 )
, ( -0.2495892950, -0.3832854473, 1.0845181219 )
, ( 1.7813504266, 1.6178237031, 0.8162655711 )
, ( -0.1985249206, -0.8343333301, 0.0538864941 )
, ( -1.7011985145, -0.1263820964, 0.4776976918 )
, ( -0.4319462812, 1.4104420482, 0.7886291537 )
, ( 0.2178372997, -0.9499557344, 0.0357871187 )
, ( -0.6294854565, -1.3078893852, 0.7653357688 )
, ( 1.7952608455, 0.6281269104, 0.2727652452 )
, ( 1.4168575317, 1.0683357171, 1.1016025378 )
, ( 1.4637371396, 0.9463877418, 1.1846214562 )
, ( -0.5263668798, 1.7315156631, 1.4428514068 )
, ( -1.2197352481, 0.9144146579, 1.0727263474 )
, ( -0.1389358881, 0.1092805780, 0.7350208828 )
, ( 1.5293954595, 0.0030278255, 1.2472867347 )
, ( -0.5258728625, 1.3782633069, 1.3495508831 )
, ( -0.1403562064, 0.2437382535, 1.3804956588 )
, ( 0.8055826339, -0.0482092025, 0.3327165165 )
, ( -0.6311979224, 0.7184578971, 0.2491045282 )
, ( 1.4685857879, -0.8347049536, 1.3670667538 )
, ( -0.6855727502, 1.6465021616, 1.0593087096 )
, ( 0.0152957411, 0.0638919221, 0.9771215985 )
);
OP SQR = ( REAL x )REAL: x * x;
PRIO MIN = 5;
OP MIN = ( []CIRCLE rc, PROC(CIRCLE)REAL f )REAL:
IF LWB rc > UPB rc
THEN 0
ELSE REAL result := f( rc[ LWB rc ] );
FOR c pos FROM LWB rc + 1 TO UPB rc DO
REAL v = f( rc[ c pos ] );
IF v < result THEN result := v FI
OD;
result
FI # MIN # ;
PRIO MAX = 5;
OP MAX = ( []CIRCLE rc, PROC(CIRCLE)REAL f )REAL:
IF LWB rc > UPB rc
THEN 0
ELSE REAL result := f( rc[ LWB rc ] );
FOR c pos FROM LWB rc + 1 TO UPB rc DO
REAL v = f( rc[ c pos ] );
IF v > result THEN result := v FI
OD;
result
FI # MAX # ;
REAL x min = circles MIN ( ( CIRCLE it )REAL: x OF it - r OF it );
REAL x max = circles MAX ( ( CIRCLE it )REAL: x OF it + r OF it );
REAL y min = circles MIN ( ( CIRCLE it )REAL: y OF it - r OF it );
REAL y max = circles MAX ( ( CIRCLE it )REAL: y OF it + r OF it );
INT box side = 500;
REAL dx = ( x max - x min ) / box side;
REAL dy = ( y max - y min ) / box side;
INT count := 0;
FOR r FROM 0 TO box side - 1 DO
REAL y = y min + ( r * dy );
FOR c FROM 0 TO box side - 1 DO
REAL x = x min + ( c * dx );
BOOL xy in circle := FALSE;
FOR c pos FROM LWB circles TO UPB circles WHILE NOT xy in circle DO
CIRCLE curr circle = circles[ c pos ];
IF SQR ( x - x OF curr circle ) + SQR ( y - y OF curr circle ) <= SQR r OF curr circle THEN
count +:= 1;
xy in circle := TRUE
FI
OD
OD
OD;
print( ( "Approximated area: ", fixed( count * dx * dy, -16, 14 ), newline ) )
END
</syntaxhighlight>
{{out}}
<pre>
Approximated area: 21.5615597720033
</pre>
Line 408 ⟶ 504:
{{out}}
area = 21.5650366037 at 5637290 scanlines
=={{header|C#}}==
===Scanline Method===
{{works with| .NET 8}}
{{trans|Java}}
<syntaxhighlight lang="C#">
using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
public static void Main(string[] args)
{
const double precision = 0.000001;
Console.WriteLine($"Approximate area = {AreaScan(precision):F8}");
}
private static double AreaScan(double precision)
{
List<double> valuesY = new List<double>();
foreach (var circle in circles)
{
valuesY.Add(circle.CentreY + circle.Radius);
valuesY.Add(circle.CentreY - circle.Radius);
}
double min = valuesY.Min();
double max = valuesY.Max();
long minY = (long)Math.Floor(min / precision);
long maxY = (long)Math.Ceiling(max / precision);
double totalArea = 0.0;
for (long i = minY; i <= maxY; i++)
{
double y = i * precision;
double right = double.NegativeInfinity;
List<PairX> pairsX = new List<PairX>();
foreach (var circle in circles)
{
if (Math.Abs(y - circle.CentreY) < circle.Radius)
{
pairsX.Add(HorizontalSection(circle, y));
}
}
pairsX.Sort((one, two) => one.X1.CompareTo(two.X1));
foreach (var pairX in pairsX)
{
if (pairX.X2 > right)
{
totalArea += pairX.X2 - Math.Max(pairX.X1, right);
right = pairX.X2;
}
}
}
return totalArea * precision;
}
private static PairX HorizontalSection(Circle circle, double y)
{
double value = Math.Pow(circle.Radius, 2) - Math.Pow(y - circle.CentreY, 2);
double deltaX = Math.Sqrt(value);
return new PairX(circle.CentreX - deltaX, circle.CentreX + deltaX);
}
private record PairX(double X1, double X2);
private record Circle(double CentreX, double CentreY, double Radius);
private static readonly List<Circle> circles = new List<Circle>
{
new Circle(1.6417233788, 1.6121789534, 0.0848270516),
new Circle(-1.4944608174, 1.2077959613, 1.1039549836),
new Circle(0.6110294452, -0.6907087527, 0.9089162485),
new Circle(0.3844862411, 0.2923344616, 0.2375743054),
new Circle(-0.2495892950, -0.3832854473, 1.0845181219),
new Circle(1.7813504266, 1.6178237031, 0.8162655711),
new Circle(-0.1985249206, -0.8343333301, 0.0538864941),
new Circle(-1.7011985145, -0.1263820964, 0.4776976918),
new Circle(-0.4319462812, 1.4104420482, 0.7886291537),
new Circle(0.2178372997, -0.9499557344, 0.0357871187),
new Circle(-0.6294854565, -1.3078893852, 0.7653357688),
new Circle(1.7952608455, 0.6281269104, 0.2727652452),
new Circle(1.4168575317, 1.0683357171, 1.1016025378),
new Circle(1.4637371396, 0.9463877418, 1.1846214562),
new Circle(-0.5263668798, 1.7315156631, 1.4428514068),
new Circle(-1.2197352481, 0.9144146579, 1.0727263474),
new Circle(-0.1389358881, 0.1092805780, 0.7350208828),
new Circle(1.5293954595, 0.0030278255, 1.2472867347),
new Circle(-0.5258728625, 1.3782633069, 1.3495508831),
new Circle(-0.1403562064, 0.2437382535, 1.3804956588),
new Circle(0.8055826339, -0.0482092025, 0.3327165165),
new Circle(-0.6311979224, 0.7184578971, 0.2491045282),
new Circle(1.4685857879, -0.8347049536, 1.3670667538),
new Circle(-0.6855727502, 1.6465021616, 1.0593087096),
new Circle(0.0152957411, 0.0638919221, 0.9771215985)
};
}
</syntaxhighlight>
{{out}}
<pre>
Approximate area = 21.56503660
</pre>
=={{header|C++}}==
<syntaxhighlight lang="c++">
#include <algorithm>
#include <cfloat>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <vector>
struct Pair_X {
double x1;
double x2;
bool operator <(const Pair_X& pair_x) const {
return x1 < pair_x.x1;
}
};
struct Circle {
double centre_x;
double centre_y;
double radius;
};
const std::vector<Circle> circles = {
Circle( 1.6417233788, 1.6121789534, 0.0848270516),
Circle(-1.4944608174, 1.2077959613, 1.1039549836),
Circle( 0.6110294452, -0.6907087527, 0.9089162485),
Circle( 0.3844862411, 0.2923344616, 0.2375743054),
Circle(-0.2495892950, -0.3832854473, 1.0845181219),
Circle( 1.7813504266, 1.6178237031, 0.8162655711),
Circle(-0.1985249206, -0.8343333301, 0.0538864941),
Circle(-1.7011985145, -0.1263820964, 0.4776976918),
Circle(-0.4319462812, 1.4104420482, 0.7886291537),
Circle( 0.2178372997, -0.9499557344, 0.0357871187),
Circle(-0.6294854565, -1.3078893852, 0.7653357688),
Circle( 1.7952608455, 0.6281269104, 0.2727652452),
Circle( 1.4168575317, 1.0683357171, 1.1016025378),
Circle( 1.4637371396, 0.9463877418, 1.1846214562),
Circle(-0.5263668798, 1.7315156631, 1.4428514068),
Circle(-1.2197352481, 0.9144146579, 1.0727263474),
Circle(-0.1389358881, 0.1092805780, 0.7350208828),
Circle( 1.5293954595, 0.0030278255, 1.2472867347),
Circle(-0.5258728625, 1.3782633069, 1.3495508831),
Circle(-0.1403562064, 0.2437382535, 1.3804956588),
Circle( 0.8055826339, -0.0482092025, 0.3327165165),
Circle(-0.6311979224, 0.7184578971, 0.2491045282),
Circle( 1.4685857879, -0.8347049536, 1.3670667538),
Circle(-0.6855727502, 1.6465021616, 1.0593087096),
Circle( 0.0152957411, 0.0638919221, 0.9771215985)
};
Pair_X horizontal_section(const Circle& circle, const double& y) {
const double value = circle.radius * circle.radius - ( y - circle.centre_y ) * ( y - circle.centre_y );
double delta_x = std::sqrt(value);
return Pair_X(circle.centre_x - delta_x, circle.centre_x + delta_x);
}
double area_scan(const double& precision) {
std::vector<double> y_values;
for ( const Circle& circle : circles ) {
y_values.emplace_back(circle.centre_y + circle.radius);
}
for ( const Circle& circle : circles ) {
y_values.emplace_back(circle.centre_y - circle.radius);
}
const double min = *min_element(y_values.begin(), y_values.end());
const double max = *max_element(y_values.begin(), y_values.end());
const int64_t min_y = std::floor(min / precision);
const int64_t max_y = std::ceil(max / precision);
double total_area = 0.0;
for ( int64_t i = min_y; i <= max_y; ++i ) {
double y = i * precision;
double right = -DBL_MAX;
std::vector<Pair_X> pairs_x;
for ( const Circle& circle : circles ) {
if ( std::fabs(y - circle.centre_y) < circle.radius ) {
pairs_x.emplace_back(horizontal_section(circle, y));
}
}
std::sort(pairs_x.begin(), pairs_x.end());
for ( const Pair_X& pair_x : pairs_x ) {
if ( pair_x.x2 > right ) {
total_area += pair_x.x2 - std::max(pair_x.x1, right);
right = pair_x.x2;
}
}
}
return total_area * precision;
}
int main() {
const double precision = 0.00001;
std::cout << "Approximate area = " << std::setprecision(9) << area_scan(precision);
}
</syntaxhighlight>
{{ out }}
<pre>
Approximate area = 21.5650366
</pre>
=={{header|D}}==
Line 708 ⟶ 1,018:
<pre>Area: 21.5650366038564</pre>
The run-time is minimal (0.03 seconds or less).
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
type TCircle = record
X,Y: double;
R: double;
end;
const Circles: array [0..24] of TCircle =(
(X: 1.6417233788; Y: 1.6121789534; R: 0.0848270516),
(X: -1.4944608174; Y: 1.2077959613; R: 1.1039549836),
(X: 0.6110294452; Y: -0.6907087527; R: 0.9089162485),
(X: 0.3844862411; Y: 0.2923344616; R: 0.2375743054),
(X: -0.2495892950; Y: -0.3832854473; R: 1.0845181219),
(X: 1.7813504266; Y: 1.6178237031; R: 0.8162655711),
(X: -0.1985249206; Y: -0.8343333301; R: 0.0538864941),
(X: -1.7011985145; Y: -0.1263820964; R: 0.4776976918),
(X: -0.4319462812; Y: 1.4104420482; R: 0.7886291537),
(X: 0.2178372997; Y: -0.9499557344; R: 0.0357871187),
(X: -0.6294854565; Y: -1.3078893852; R: 0.7653357688),
(X: 1.7952608455; Y: 0.6281269104; R: 0.2727652452),
(X: 1.4168575317; Y: 1.0683357171; R: 1.1016025378),
(X: 1.4637371396; Y: 0.9463877418; R: 1.1846214562),
(X: -0.5263668798; Y: 1.7315156631; R: 1.4428514068),
(X: -1.2197352481; Y: 0.9144146579; R: 1.0727263474),
(X: -0.1389358881; Y: 0.1092805780; R: 0.7350208828),
(X: 1.5293954595; Y: 0.0030278255; R: 1.2472867347),
(X: -0.5258728625; Y: 1.3782633069; R: 1.3495508831),
(X: -0.1403562064; Y: 0.2437382535; R: 1.3804956588),
(X: 0.8055826339; Y: -0.0482092025; R: 0.3327165165),
(X: -0.6311979224; Y: 0.7184578971; R: 0.2491045282),
(X: 1.4685857879; Y: -0.8347049536; R: 1.3670667538),
(X: -0.6855727502; Y: 1.6465021616; R: 1.0593087096),
(X: 0.0152957411; Y: 0.0638919221; R: 0.9771215985)
);
procedure CalculateCircleArea(Memo: TMemo; BoxPoints: integer = 500);
var MinX,MinY,MaxX,MaxY,Area: double;
var X,Y,BoxScaleX,BoxScaleY: double;
var I,Row,Col,Count: integer;
var Circle: TCircle;
begin
{Get minimum and maximum size of all the circles}
MinX:=MaxDouble; MinY:=MaxDouble;
MaxX:=MinDouble; MaxY:=MinDouble;
for I:=0 to High(Circles) do
begin
Circle:=Circles[I];
MinX:=min(MinX,Circle.X - Circle.R);
MaxX:=max(MaxX,Circle.X + Circle.R);
MinY:=min(MinY,Circle.Y - Circle.R);
MaxY:=max(MaxY,Circle.Y + Circle.R);
end;
{Calculate scaling factor for X/Y dimension of box}
BoxScaleX:=(MaxX - MinX) / BoxPoints;
BoxScaleY:=(MaxY - MinY) / BoxPoints;
Count:=0;
{Iterate through all X/Y BoxPoints}
for Row:=0 to BoxPoints-1 do
begin
{Get scaled and offset Y pos}
Y:=MinY + Row * BoxScaleY;
for Col:=0 to BoxPoints-1 do
begin
{Get scaled and offset X pos}
X:=MinX + Col * BoxScaleX;
for I:=0 to High(Circles) do
begin
Circle:=Circles[I];
{Check to see if point is in circle}
if (sqr(X - Circle.X) + sqr(Y - Circle.Y)) <= (Sqr(Circle.R)) then
begin
Inc(Count);
{Only count one circle}
break;
end;
end;
end;
end;
{Calculate area from the box scale}
Area:=Count * BoxScaleX * BoxScaleY;
{Display it}
Memo.Lines.Add(Format('Side: %5d Points: %9.0n Area: %3.18f',[BoxPoints,BoxPoints*BoxPoints+0.0,Area]));
end;
procedure TotalCirclesArea(Memo: TMemo);
begin
CalculateCircleArea(Memo, 500);
CalculateCircleArea(Memo, 1000);
CalculateCircleArea(Memo, 1500);
CalculateCircleArea(Memo, 5000);
end;
</syntaxhighlight>
{{out}}
<pre>
Side: 500 Points: 250,000 Area: 21.5615597720033172
Side: 1,000 Points: 1,000,000 Area: 21.5638384878351026
Side: 5,000 Points: 25,000,000 Area: 21.5649556428787861
Side: 15,000 Points: 225,000,000 Area: 21.5650079689460341
Elapsed Time: 01:23.134 min
</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang=easylang>
# with Montecarlo sampling
repeat
s$ = input
until s$ = ""
c[][] &= number strsplit s$ " "
.
# mark inner circles
for i to len c[][]
for j to len c[][]
if i <> j
dx = abs (c[i][1] - c[j][1])
dy = abs (c[i][2] - c[j][2])
d = sqrt (dx * dx + dy * dy)
if d + c[j][3] < c[i][3]
c[j][3] = 0
.
.
.
.
# find bounding box and remove marked circles
i = len c[][]
while i >= 1
if 0 = 1 and c[i][3] = 0
swap c[i][] c[len c[][]][]
len c[][] -1
else
maxx = higher (c[i][1] + c[i][3]) maxx
minx = lower (c[i][1] - c[i][3]) minx
maxy = higher (c[i][2] + c[i][3]) maxy
miny = lower (c[i][2] - c[i][3]) miny
c[i][3] = c[i][3] * c[i][3]
.
i -= 1
.
ntry = 10000000
print ntry & " samples ..."
for try to ntry
px = (maxx - minx) * randomf + minx
py = (maxy - miny) * randomf + miny
for i to len c[][]
dx = px - c[i][1]
dy = py - c[i][2]
if dx * dx + dy * dy <= c[i][3]
inside += 1
break 1
.
.
.
numfmt 4 0
print inside / ntry * (maxx - minx) * (maxy - miny)
#
input_data
1.6417233788 1.6121789534 0.0848270516
-1.4944608174 1.2077959613 1.1039549836
0.6110294452 -0.6907087527 0.9089162485
0.3844862411 0.2923344616 0.2375743054
-0.2495892950 -0.3832854473 1.0845181219
1.7813504266 1.6178237031 0.8162655711
-0.1985249206 -0.8343333301 0.0538864941
-1.7011985145 -0.1263820964 0.4776976918
-0.4319462812 1.4104420482 0.7886291537
0.2178372997 -0.9499557344 0.0357871187
-0.6294854565 -1.3078893852 0.7653357688
1.7952608455 0.6281269104 0.2727652452
1.4168575317 1.0683357171 1.1016025378
1.4637371396 0.9463877418 1.1846214562
-0.5263668798 1.7315156631 1.4428514068
-1.2197352481 0.9144146579 1.0727263474
-0.1389358881 0.1092805780 0.7350208828
1.5293954595 0.0030278255 1.2472867347
-0.5258728625 1.3782633069 1.3495508831
-0.1403562064 0.2437382535 1.3804956588
0.8055826339 -0.0482092025 0.3327165165
-0.6311979224 0.7184578971 0.2491045282
1.4685857879 -0.8347049536 1.3670667538
-0.6855727502 1.6465021616 1.0593087096
0.0152957411 0.0638919221 0.9771215985
</syntaxhighlight>
=={{header|EchoLisp}}==
Line 1,510 ⟶ 2,014:
<syntaxhighlight lang="java">
public class
/*
Line 1,635 ⟶ 2,139:
}
}</syntaxhighlight>
===Scanline Method===
Alternative example using the Scanline method.
<syntaxhighlight lang="java">
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public final class TotalCirclesArea {
public static void main(String[] args) {
final double precision = 0.000_001;
System.out.println(String.format("%s%.8f", "Approximate area = ", areaScan(precision)));
}
private static double areaScan(double precision) {
List<Double> valuesY = new ArrayList<Double>();
for ( Circle circle : circles ) {
valuesY.add(circle.centreY + circle.radius);
}
for ( Circle circle : circles ) {
valuesY.add(circle.centreY - circle.radius);
}
final double min = valuesY.stream().min(Double::compare).get();
final double max = valuesY.stream().max(Double::compare).get();
final long minY = (long) Math.floor(min / precision);
final long maxY = (long) Math.ceil(max / precision);
double totalArea = 0.0;
for ( long i = minY; i <= maxY; i++ ) {
final double y = i * precision;
double right = Double.NEGATIVE_INFINITY;
List<PairX> pairsX = new ArrayList<PairX>();
for ( Circle circle : circles ) {
if ( Math.abs(y - circle.centreY) < circle.radius ) {
pairsX.add(horizontalSection(circle, y));
}
}
Collections.sort(pairsX, (one, two) -> Double.compare(one.x1, two.x1) );
for ( PairX pairX : pairsX ) {
if ( pairX.x2 > right ) {
totalArea += pairX.x2 - Math.max(pairX.x1, right);
right = pairX.x2;
}
}
}
return totalArea * precision;
}
private static PairX horizontalSection(Circle circle, double y) {
final double value = circle.radius * circle.radius - ( y - circle.centreY ) * ( y - circle.centreY );
final double deltaX = Math.sqrt(value);
return new PairX(circle.centreX - deltaX, circle.centreX + deltaX);
}
private static record PairX(double x1, double x2) {}
private static record Circle(double centreX, double centreY, double radius) {}
private static final List<Circle> circles = List.of(
new Circle( 1.6417233788, 1.6121789534, 0.0848270516),
new Circle(-1.4944608174, 1.2077959613, 1.1039549836),
new Circle( 0.6110294452, -0.6907087527, 0.9089162485),
new Circle( 0.3844862411, 0.2923344616, 0.2375743054),
new Circle(-0.2495892950, -0.3832854473, 1.0845181219),
new Circle( 1.7813504266, 1.6178237031, 0.8162655711),
new Circle(-0.1985249206, -0.8343333301, 0.0538864941),
new Circle(-1.7011985145, -0.1263820964, 0.4776976918),
new Circle(-0.4319462812, 1.4104420482, 0.7886291537),
new Circle( 0.2178372997, -0.9499557344, 0.0357871187),
new Circle(-0.6294854565, -1.3078893852, 0.7653357688),
new Circle( 1.7952608455, 0.6281269104, 0.2727652452),
new Circle( 1.4168575317, 1.0683357171, 1.1016025378),
new Circle( 1.4637371396, 0.9463877418, 1.1846214562),
new Circle(-0.5263668798, 1.7315156631, 1.4428514068),
new Circle(-1.2197352481, 0.9144146579, 1.0727263474),
new Circle(-0.1389358881, 0.1092805780, 0.7350208828),
new Circle( 1.5293954595, 0.0030278255, 1.2472867347),
new Circle(-0.5258728625, 1.3782633069, 1.3495508831),
new Circle(-0.1403562064, 0.2437382535, 1.3804956588),
new Circle( 0.8055826339, -0.0482092025, 0.3327165165),
new Circle(-0.6311979224, 0.7184578971, 0.2491045282),
new Circle( 1.4685857879, -0.8347049536, 1.3670667538),
new Circle(-0.6855727502, 1.6465021616, 1.0593087096),
new Circle( 0.0152957411, 0.0638919221, 0.9771215985)
);
}
</syntaxhighlight>
{{ out }}
<pre>
Approximate area = 21.56503660
</pre>
=={{header|jq}}==
Line 1,685 ⟶ 2,283:
($x * precision) as $y
| .right = - infinite
| ($circles
| reduce ($segments | sort_by(.x))[] as $p (.;
| .total * precision ;
Line 1,768 ⟶ 2,365:
inside = 0
# For every point in my grid.
for x in
inside += any(r2 .> (x .- xc) .^ 2 + (y .- yc) .^ 2)
end
boxarea = (xmax - xmin) * (ymax - ymin)
Line 3,271 ⟶ 3,868:
</pre>
Note that the error on the Monte Carlo sampling is actually very high; the above run happened to deliver a figure closer to the real value than usual.
=={{header|Uiua}}==
{{works with|Uiua|0.10.0}}
Developed mainly to play with Uiua's image handling. Getting a very rough area figure is a bonus.
<syntaxhighlight lang="Uiua">
Cs ← [[1.6417233788 1.6121789534 0.0848270516]
[¯1.4944608174 1.2077959613 1.1039549836]
[0.6110294452 ¯0.6907087527 0.9089162485]
[0.3844862411 0.2923344616 0.2375743054]
[¯0.249589295 ¯0.3832854473 1.0845181219]
[1.7813504266 1.6178237031 0.8162655711]
[¯0.1985249206 ¯0.8343333301 0.0538864941]
[¯1.7011985145 ¯0.1263820964 0.4776976918]
[¯0.4319462812 1.4104420482 0.7886291537]
[0.2178372997 ¯0.9499557344 0.0357871187]
[¯0.6294854565 ¯1.3078893852 0.7653357688]
[1.7952608455 0.6281269104 0.2727652452]
[1.4168575317 1.0683357171 1.1016025378]
[1.4637371396 0.9463877418 1.1846214562]
[¯0.5263668798 1.7315156631 1.4428514068]
[¯1.2197352481 0.9144146579 1.0727263474]
[¯0.1389358881 0.109280578 0.7350208828]
[1.5293954595 0.0030278255 1.2472867347]
[¯0.5258728625 1.3782633069 1.3495508831]
[¯0.1403562064 0.2437382535 1.3804956588]
[0.8055826339 ¯0.0482092025 0.3327165165]
[¯0.6311979224 0.7184578971 0.2491045282]
[1.4685857879 ¯0.8347049536 1.3670667538]
[¯0.6855727502 1.6465021616 1.0593087096]
[0.0152957411 0.0638919221 0.9771215985]]
# Scale total range to (0-Dim,0-Dim), save MaxXorY for later.
Dim ← 500
MinXY ← /↧≡(-⊃(⊢|↘1)↻¯1) Cs
Zcs ← ≡(⬚0-MinXY) Cs
MaxXorY ← /↥/↥≡(+⊃(⊢|↘1)↻¯1) Zcs
Scs ← ⁅×Dim÷ MaxXorY Zcs
# For each r generate a 2r.2r grid and set cells that are within circle.
InCircle ← <ⁿ2⟜(⊞(/+≡ⁿ2⊟).+⇡⊃(×2|¯))
# Fade this circle out, then add to accumulator, offset appropriately.
Filler ← ⍜(↻|⬚0+)⊙: ⊃(+¯|×0.1InCircle) ⊃(⊢|↘1) ↻¯1
# Fold over all circles, accumulating into a blank grid.
⍜now(∧Filler Scs ↯Dim_Dim 0)
&p &pf "Runtime (s): "
×ⁿ2 ÷Dim MaxXorY (⧻⊚≠0) ♭.
&p &pf "*Very* approximate area: "
# Uncomment to save image.
# &ime "png"
# &fwa "UiuaOverlappingCircles.png"
</syntaxhighlight>
{{out}}
<pre>
stdout:
Runtime (s): 3.7929999999978463
*Very* approximate area: 21.56451023743893
</pre>
[[File:UiuaOverlappingCircles.png|300px|thumbnail|center|Overlapping translucent circles]]
<p></p>
=={{header|VBA}}==
Line 3,530 ⟶ 4,188:
{{libheader|Wren-math}}
Limited to 3000 boxes to finish in a reasonable time (about 25 seconds) with reasonable precision.
<syntaxhighlight lang="
import "./math" for Nums
var Circle = Tuple.create("Circle", ["x", "y", "r"])
Line 3,592 ⟶ 4,250:
{{libheader|Wren-sort}}
Quicker (about 4.7 seconds) and more precise (limited to 5 d.p. but achieves 7) than the above version.
<syntaxhighlight lang="
import "./math" for Nums
import "./sort" for Sort
var Point = Tuple.create("Point", ["x", "y"])
| |||