Curve that touches three points: Difference between revisions

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

TYPE Point=[INT x,y]

 

PROC QuadraticCurve(Point POINTER p1,p2,p3 REAL POINTER a,b,c)

REAL x1,y1,x2,y2,x3,y3,x11,x22,x33,m,n,tmp1,tmp2,tmp3,tmp4,r1

 

 

RealMult(x1,x1,x11) ;x11=x1^2

RealSub(x3,x2,n) ;n=x3-x2

RealMult(m,n,tmp1) ;tmp1=m*n

 

IF IsNegative(tmp1) THEN

INT yi

 

RealMult(xr,xr,xr2) ;xr2=x^2

RealMult(a,xr2,tmp1) ;tmp1=a*x^2

RealAdd(tmp1,tmp2,tmp3) ;tmp3=a*x^2+b*x

RealAdd(tmp3,c,yr) ;y3=a*x^2+b*x+c

RETURN (yi)

 

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Curve_that_touches_three_points.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

Find center and radius of circle that touches the 3 points. Solve with simple linear algebra. In this case no division by zero.

with Ada.Numerics.Generic_Elementary_Functions;

 

Put ("Center : "); Put ("("); Put (Xc); Put (", "); Put (Yc); Put (")"); New_Line;

Put ("Radius : "); Put (R); New_Line;

{{out}}

<pre>

 

=={{header|AutoHotkey}}==

x1:=p1.1, y1:=p1.2, x2:=p2.1, y2:=p2.2, x3:=p3.1, y3:=p3.2

m:=x1-x2, n:=x3-x2, m:= ((m*n)<0?-1:1) * m

c:=y1 - a*x1**2 - b*x1

return [a,b,c]

v := QuadraticCurve(p1,p2,p3)

a := v.1, b:= v.2, c:= v.3

res .= "[" x ", " y "]`n"

}

; for plotting, use code from [https://rosettacode.org/wiki/Plot_coordinate_pairs#AutoHotkey RosettaCode: Plot Coordinate Pairs]

Outputs:<pre>Y = -0.021111 X^2 +4.433333 X -32.222222

[100, 200.000000]

[200, 10.000000]</pre>

 

=={{header|Go}}==

 

The resulting 'curve' is then saved to a .png file where it can be viewed with a utility such as EOG.

 

import "github.com/fogleman/gg"

dc.Stroke()

dc.SavePNG("quadratic_curve.png")

 

=={{header|J}}==

 

=={{header|Julia}}==

 

struct Point; x::Float64; y::Float64; end

x = a-r:0.25:a+r

y0 = sqrt.(r^2 .- (x .- a).^2)

<pre>

The circle with center at x = 105.0, y = 81.31578947368422 and radius 118.78948534384199.

</pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

===Built-in===

cs = Circumsphere[pts]

{{out}}

Outputs the circle:

and a graphical representation of the input points and the circle.

===Alternate implementation===

createCircle[{{x1_, y1_}, {x2_, y2_}, {x3_, y3_}}] :=

With[{a = Det[({{x1, y1, 1}, {x2, y2, 1}, {x3, y3, 1}})],

Circle[{-(d/(2 a)), -(e/(2 a))}, Sqrt[(d^2 + e^2)/(4 a^2) - f/a]]]

cs = createCircle[pts]

{{out}}

Outputs the circle:

{{trans|Go}}

{{libheader|imageman}}

 

type

let color = ColorRGBF([float32 0, 0, 0]) # Black.

img.drawPolyline(closed = false, color, P.points(N))

 

=={{header|Perl}}==

use List::Util qw(max min);

 

open $fh, '>', 'curve-3-points.svg';

print $fh $svg->xmlify(-namespace=>'svg');

 

=={{header|Phix}}==

{{trans|zkl}}

 

=={{header|Raku}}==

(formerly Perl 6)

Kind of bogus. There are an infinite number of curves that pass through those three points. I'll assume a quadratic curve. Lots of bits and pieces borrowed from other tasks to avoid relying on library functions.

 

Saved as a png for wide viewing support. Note that png coordinate systems have 0,0 in the upper left corner.

 

 

# Solve for a quadratic line that passes through those points

 

 

 

my $png = Image::PNG::Portable.new: :width($w), :height($h);

 

}

 

 

$png.write: 'Curve-3-points-perl6.png';

sub rref (@m) {

return unless @m;

for ^$rows -> $r {

$lead < $cols or return @m;

}

@m[$i, $r] = @m[$r, $i] if $r != $i;

for ^$rows -> $n {

next if $n == $r;

}

++$lead;

sub line($x0 is copy, $y0 is copy, $x1 is copy, $y1 is copy, $png, @rgb) {

my $steep = abs($y1 - $y0) > abs($x1 - $x0);

if $steep {

($x0, $y0) = ($y0, $x0);

}

$error += $Δerror;

$y += $y-step;

$error -= 1.0;

 

sub dot ($X is copy, $Y is copy, @rgb, $png, $radius = 3) {

for ($X X+ -$radius .. $radius) X ($Y X+ -$radius .. $radius) -> ($x, $y) {

}

See [https://github.com/thundergnat/rc/blob/master/img/Curve-3-points-perl6.png Curve-3-points-perl6.png] (offsite .png image)

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|DOME}}

import "dome" for Window

 

}

}

 

=={{header|zkl}}==

Uses Image Magick and

the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

var p=L(L(10.0, 10.0), L(100.0, 200.0), L(200.0, 10.0)); // (x,y)

}

img.writeJPGFile("quadraticCurve.zkl.jpg");

{{out}}

Image at [http://www.zenkinetic.com/Images/RosettaCode/quadraticCurve.zkl.jpg quadratic curve]