Find the intersection of two lines: Difference between revisions

<br><br>

 

 

{{works with|Ada|Ada|2005}}

 

 

procedure Intersection_Of_Two_Lines

Ada.Text_IO.Put_Line(p.y'Img);

end Intersection_Of_Two_Lines;

{{out}}

<pre> 5.00000E+00 5.00000E+00

=={{header|ALGOL 68}}==

Using "school maths".

# mode to hold a point #

MODE POINT = STRUCT( REAL x, y );

print( ( fixed( x OF i, -8, 4 ), fixed( y OF i, -8, 4 ), newline ) )

 

{{out}}

<pre>

5.0000 5.0000

</pre>

=={{header|AWK}}==

# syntax: GAWK -f FIND_THE_INTERSECTION_OF_TWO_LINES.AWK

# converted from Ring

return(1)

}

{{out}}

<pre>

 

=={{header|BASIC}}==

==={{header|Sinclair ZX81 BASIC}}===

{{trans|REXX}} (version 1)

Works with 1k of RAM.

20 LET YA=0

30 LET XB=6

150 PRINT "YAB=";Y

160 PRINT "YCD=";YC-XC*((YD-YC)/(XD-XC))+X*((YD-YC)/(XD-XC))

{{out}}

<pre>THE TWO LINES ARE:

YCD=5

INTERSECTION: 5,5</pre>

 

=={{header|C}}==

This implementation is generic and considers any two lines in the XY plane and not just the specified example. Usage is printed on incorrect invocation.

#include<stdlib.h>

#include<stdio.h>

c.y = NAN;

}

c.x = a1.x;

c.y = (a1.x-b1.x)*slopeB + b1.y;

}

c.x = b1.x;

}

else{

c = intersectionPoint(extractPoint(argV[1]),extractPoint(argV[2]),extractPoint(argV[3]),extractPoint(argV[4]));

printf("The lines do not intersect, they are either parallel or co-incident.");

else

return 0;

}

Invocation and output:

<pre>

</pre>

 

using System.Drawing;

public class Program

Console.WriteLine(FindIntersection(p(0f, 0f), p(1f, 1f), p(1f, 2f), p(4f, 5f)));

}

{{out}}

<pre>

=={{header|C++}}==

 

#include <cmath>

using namespace std;

 

}

 

///\return true if found, false if not found or error

{

double detL1 = Det(x1, y1, x2, y2);

double y3my4 = y3 - y4;

 

double denom = Det(x1mx2, y1my2, x3mx4, y3my4);

{

ixOut = NAN;

}

 

ixOut = xnom / denom;

iyOut = ynom / denom;

return false;

 

// **Simple crossing diagonal lines**

 

double x1=4.0, y1=0.0;

double x2=6.0, y2=10.0;

double x3=0.0, y3=3.0;

double x4=10.0, y4=7.0;

assert(fabs(ix - 5.0) < eps);

assert(fabs(iy - 5.0) < eps);

 

{{out}}

<pre>result 1,5,5</pre>

 

=={{header|D}}==

{{trans|Kotlin}}

 

struct Point {

l2 = Line(Point(1.0, 2.0), Point(4.0, 5.0));

writeln(findIntersection(l1, l2));

 

{{out}}

<pre>{5.000000, 5.000000}

{-inf, -inf}</pre>

 

=={{header|F_Sharp|F#}}==

(*

Find the point of intersection of 2 lines.

intersect (fn (4.0,0.0) (6.0,10.0)) (fn (0.0,3.0) (10.0,7.0))

intersect {a=3.18;b=4.23;c=7.13} {a=6.36;b=8.46;c=9.75}

{{out}}

<pre>

-10.00x + 2.00y = -40.00 intersects -4.00x + 10.00y = 30.00 at x=5.00 y=5.00

3.18x + 4.23y = 7.13 does not intersect 6.36x + 8.46y = 9.75

</pre>

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

write(*,*)x,y

end subroutine intersect

{{out}}

<pre> 5.00000000 5.00000000 </pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

#Define NaN 0 / 0 ' FreeBASIC returns -1.#IND

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre> 5 5

-1.#IND -1.#IND</pre>

=={{header|Go}}==

package main

 

}

}

{{Out}}

<pre>{5 5}</pre>

 

=={{header|Haskell}}==

 

type Point = (Float, Float)

case interSection of

Left x -> x

{{Out}}

<pre>(5.0,5.0)</pre>

{{trans|C++}}

'''Solution:'''

 

'''Examples:'''

line2=: 0 3 ,: 10 7

line3=: 0 3 ,: 10 7.1

__ __

findIntersection line6 ,: line7

 

=={{header|Java}}==

{{trans|Kotlin}}

private static class Point {

double x, y;

System.out.println(findIntersection(l1, l2));

}

{{out}}

<pre>{5.000000, 5.000000}

{{Trans|Haskell}}

===ES6===

'use strict';

// INTERSECTION OF TWO LINES ----------------------------------------------

]);

return show(lrIntersection.Left || lrIntersection.Right);

{{Out}}

<pre>[5,5]</pre>

points P1 and P2. Array destructuring is used for simplicity.

 

def det(a;b;c;d): a*d - b*c ;

 

then error("lineIntersect: parallel lines")

else [.xnom/.denom, .ynom/.denom]

Example:

{{out}}

 

=={{header|Julia}}==

{{trans|Kotlin}}

 

x::T

y::T

l1 = Line(Point{Float64}(0, 0), Point{Float64}(1, 1))

l2 = Line(Point{Float64}(1, 2), Point{Float64}(4, 5))

 

{{out}}

<pre>Point{Float64}(5.0, 5.0)

Point{Float64}(-Inf, -Inf)</pre>

 

=={{header|Kotlin}}==

{{trans|C#}}

 

class PointF(val x: Float, val y: Float) {

l2 = LineF(PointF(1f, 2f), PointF(4f, 5f))

println(findIntersection(l1, l2))

 

{{out}}

{-Infinity, -Infinity}

</pre>

 

=={{header|Lua}}==

{{trans|C#}}

local d = (s1.x - e1.x) * (s2.y - e2.y) - (s1.y - e1.y) * (s2.x - e2.x)

local a = s1.x * e1.y - s1.y * e1.x

local line1start, line1end = {x = 4, y = 0}, {x = 6, y = 10}

local line2start, line2end = {x = 0, y = 3}, {x = 10, y = 7}

{{out}}

<pre>5 5</pre>

 

=={{header|Maple}}==

line(L1, [point(A,[4,0]), point(B,[6,10])]):

line(L2, [point(C,[0,3]), point(E,[10,7])]):

{{Output|Out}}

<pre>[5, 5]</pre>

 

=={{header|MATLAB}}==

function cross=intersection(line1,line2)

a=polyfit(line1(:,1),line1(:,2),1);

cross=[a(1) -1; b(1) -1]\[-a(2);-b(2)];

end

{{out}}

<pre>line1=[4 0; 6 10]; line2=[0 3; 10 7]; cross=intersection(line1,line2)

5.0000

</pre>

=={{header|Modula-2}}==

FROM RealStr IMPORT RealToStr;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar;

 

=={{header|Perl}}==

If warning are enabled the second print will issue a warning since we are trying to print out an undef

 

sub intersect {

my ($x1, $y1, $x2, $y2, $x3, $y3, $x4, $y4) = @_;

($ix, $iy) = intersect(0, 0, 1, 1, 1, 2, 4, 5);

print "$ix $iy\n";

 

 

 

}

 

 

 

 

 

 

=={{header|Python}}==

 

 

 

 

 

 

 

 

# intersection :: Line -> Line -> Either String Point

def intersection(ab):

def delta(f):

return lambda x: f(fst(x)) - f(snd(x))

 

def go(pq):

[delta(fst), delta(snd)]

)([ab, pq])

[abD, pqD] = map(

lambda xy: prodDiff(

), [ab, pq]

)

[lambda abpq: prodDiff(

[abD, fst(abpq), pqD, snd(abpq)]) / determinant]

 

 

 

# Left :: a -> Either a b

def Left(x):

 

 

# Right :: b -> Either a b

def Right(x):

 

 

 

 

# bindLR (>>=) :: Either a -> (a -> Either b) -> Either b

def bindLR(m):

return lambda mf: (

)

 

# fst :: (a, b) -> a

def fst(tpl):

return tpl[0]

 

# snd :: (a, b) -> b

def snd(tpl):

return tpl[1]

 

 

# MAIN ---

<pre>(5.0, 5.0)</pre>

 

=={{header|Racket}}==

{{trans|C++}}

(define (det a b c d) (- (* a d) (* b c))) ; determinant

 

 

(module+ test (line-intersect 4 0 6 10

 

{{out}}

<pre>5

5</pre>

 

=={{header|REXX}}==

Naive implementation.

To be improved for parallel lines and degenerate lines such as y=5 or x=8.

Parse Value '(4.0,0.0)' With '(' xa ',' ya ')'

Parse Value '(6.0,10.0)' With '(' xb ',' yb ')'

Say 'yab='y

Say 'ycd='yc-xc*((yd-yc)/(xd-xc))+x*((yd-yc)/(xd-xc))

{{out}}

<pre>The two lines are:

<br>

Variables are named after the Austrian notation for a straight line: y=k*x+d

say ggx1('0.0 0.0 0.0 10.0 0.0 3.0 10.0 7.0')

say ggx1('0.0 0.0 0.0 10.0 0.0 3.0 10.0 7.0')

If res='' Then /* not any special case */

res='Intersection is ('||x'/'y')' /* that's the result */

{{out}}

<pre>A=(4.0/0.0) B=(6.0/10.0) C=(0.0/3.0) D=(10.0/7.0)

 

=={{header|Ring}}==

# Project : Find the intersection of two lines

 

see "ycd=" + (yc-xc*((yd-yc)/(xd-xc))+x*((yd-yc)/(xd-xc))) + nl

see "intersection: " + x + "," + y + nl

Output:

<pre>

ycd=5

intersection: 5,5

</pre>

 

=={{header|Ruby}}==

 

class Line

 

def to_s

end

 

 

puts "Line #{l1} intersects line #{l2} at #{l1.intersect(l2)}."

{{out}}

 

=={{header|Rust}}==

struct Point {

x: f64,

let l2 = Line(Point::new(1.0, 2.0), Point::new(4.0, 5.0));

println!("{:?}", l1.intersect(l2));

{{Out}}

<pre>

 

=={{header|Scala}}==

val (l1, l2) = (LineF(PointF(4, 0), PointF(6, 10)), LineF(PointF(0, 3), PointF(10, 7)))

 

println(findIntersection(l01, l02))

 

{{Out}}See it in running in your browser by [https://scalafiddle.io/sf/DAqMtEx/0 (JavaScript)]

or by [https://scastie.scala-lang.org/WQOqakOlQnaBRFBa1PuRYw Scastie (JVM)].

=={{header|Sidef}}==

 

 

func intersection(ax, ay, bx, by,

say ('Intersection point: ', intersection(4,0, 6,10, 0,3, 10,7))

say ('Intersection point: ', intersection(4,0, 6,10, 0,3, 10,7.1))

{{out}}

<pre>

 

=={{header|Swift}}==

var x: Double

var y: Double

return Point(x: p1.x, y: (p1.x - other.p1.x) * theirSlope + other.p1.y)

} else if theirSlope.isNaN && !ourSlope.isNaN {

} else {

let x = (ourSlope*p1.x - theirSlope*other.p1.x + other.p1.y - p1.y) / (ourSlope - theirSlope)

let l2 = Line(p1: Point(x: 0.0, y: 3.0), p2: Point(x: 10.0, y: 7.0))

 

{{out}}

<pre>Intersection at : Point(x: 5.0, y: 5.0)</pre>

 

=={{header|zkl}}==

{{trans|C++}}

detAB,detCD := det(ax,ay, bx,by), det(cx,cy, dx,dy);

abDx,cdDx := ax - bx, cx - dx; // delta x

return(xnom/denom, ynom/denom);

}

{{out}}

<pre>