Find the intersection of two lines: Difference between revisions

<br>The 2^nd line passes though &nbsp; <big> (0,3) </big> &nbsp; and &nbsp; <big> (10,7)</big> .

<br><br>

 

=={{header|360 Assembly}}==

{{trans|Rexx}}

INTERSEC CSECT

USING INTERSEC,R13 base register

PG DC CL80' '

REGEQU

{{out}}

<pre>

5.000 5.000

</pre>

 

{{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|AutoHotkey}}==

x1 := L1[1,1], y1 := L1[1,2]

x2 := L1[2,1], y2 := L1[2,2]

return ((x1*y2-y1*x2)*(x3-x4) - (x1-x2)*(x3*y4-y3*x4)) / ((x1-x2)*(y3-y4) - (y1-y2)*(x3-x4)) ", "

. ((x1*y2-y1*x2)*(y3-y4) - (y1-y2)*(x3*y4-y3*x4)) / ((x1-x2)*(y3-y4) - (y1-y2)*(x3-x4))

L2 := [[0,3], [10,7]]

Outputs:<pre>5.000000, 5.000000</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|Clojure}}==

(defn compute-line [pt1 pt2]

(let [[x1 y1] pt1

{:x x

:y (+ (* (:slope line1) x)

 

{{out}}

(intercept line1 line2) ; {:x 5, :y 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>

=={{header|Factor}}==

{{works with|Factor|0.99 2020-01-23}}

math.matrices.laplace math.vectors prettyprint sequences ;

 

{ 4 0 } { 6 10 } { 0 3 } { 10 7 } intersection .

{ 4 0 } { 6 10 } { 0 3 } { 10 7+1/10 } intersection .

{{out}}

<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}}

 

==== GeometryTypes library version ====

 

a = LineSegment(Point2f0(4, 0), Point2f0(6, 10))

b = LineSegment(Point2f0(0, 3), Point2f0(10, 7))

@show intersects(a, b) # --> intersects(a, b) = (true, Float32[5.0, 5.0])

 

=={{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>

 

InfiniteLine[{{4, 0}, {6, 10}}],

InfiniteLine[{{0, 3}, {10, 7}}]

{{out}}

 

=={{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)

 

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

FROM RealStr IMPORT RealToStr;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar;

 

=={{header|Nim}}==

{{trans|Go}}

Line = tuple

slope: float

var line1 = createLine((4.0, 0.0), (6.0, 10.0))

var line2 = createLine((0.0, 3.0), (10.0, 7.0))

line1 = createLine((0.0, 0.0), (1.0, 1.0))

line2 = createLine((1.0, 2.0), (4.0, 5.0))

{{out}}

<pre>

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|Phix}}==

 

=={{header|Processing}}==

 

// test lineIntersect() with visual and textual output

float lineA[] = {4, 0, 6, 10}; // try 4, 0, 6, 4

float y = Ay1 + uA * (Ay2 - Ay1);

return new PVector(x, y);

 

==={{header|Processing Python mode}}===

 

 

def setup():

x = Ax1 + uA * (Ax2 - Ax1)

y = Ay1 + uA * (Ay2 - Ay1)

 

=={{header|Python}}==

Find the intersection without importing third-party libraries.

""" returns a (x, y) tuple or None if there is no intersection """

d = (By2 - By1) * (Ax2 - Ax1) - (Bx2 - Bx1) * (Ay2 - Ay1)

(e, f), (g, h) = (0, 3), (10, 7) # for non intersecting test

pt = line_intersect(a, b, c, d, e, f, g, h)

 

{{Out}}

 

{{Works with|Python|3.7}}

 

from itertools import product

# MAIN ---

if __name__ == '__main__':

{{out}}

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

{{libheader|Shapely}}

Find the intersection by importing the external [https://shapely.readthedocs.io/en/latest/manual.html Shapely] library.

 

if __name__ == "__main__":

line1 = LineString([(4, 0), (6, 10)])

line2 = LineString([(0, 3), (10, 7)])

{{out}}

<pre>POINT (5 5)</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}}

{{trans|zkl}}

 

Real $cx, Real $cy, Real $dx, Real $dy ) {

 

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>Intersection point: (5 5)

Intersection point: Lines are parallel

</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)].

{{trans|Raku}}

 

 

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

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>

{{trans|Rexx}}

Simple version:

([A](2,2)-[A](1,2))/([A](2,1)-[A](1,1))→B

[A](1,2)-[A](1,1)*B→A

A+X*B→Y

C+X*D→Z

{{out}}

<pre>

</pre>

Full version:

{4,2}→Dim([B])

0→M

End

End

{{out}}

<pre>

{{works with|VBA|6.5}}

{{works with|VBA|7.1}}

 

Public Type Point

Debug.Assert ip.invalid

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>{X=5, Y=5}

=={{header|Wren}}==

{{trans|Kotlin}}

construct new(x, y) {

_x = x

l1 = Line.new(Point.new(0, 0), Point.new(1, 1))

l2 = Line.new(Point.new(1, 2), Point.new(4, 5))

 

{{out}}

(5, 5)

(-infinity, -infinity)

</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>