Rosetta Code

Talk:Find the intersection of two lines: Difference between revisions

Page Discussion

Talk:Find the intersection of two lines (view source)

Revision as of 21:04, 29 December 2021

1,347 bytes added ,  2 years ago
→‎javascript
m (→‎a REXX version of a REXX version: included comments that were added to REXX version 2, added more comments.)
 
(6 intermediate revisions by 4 users not shown)
Line 1:
==a REXX version of a REXX version==
This REXX version is a re-write of version 2 of the REXX entry,   with:
::*   added the required comment so that this REXX version would execute on VM/CMS and MVS/TSO
::*   aligned indentation for all   '''do-end'''   blocks   (and encapsulated statements)
::*   elided distracting superfluous zeroes and decimal pointszeros in (decimal) integers
::*   elides theelided superfluous and detracting use ofdecimal concatenationpoints  in ('''││''')integers
::*   elides the superfluous and distracting use of concatenation   ('''││''')
::*   a unique symbol instead of a null literal for a special case
::*   aligns the data points and results in the output
::*   adds whitespace to make arithmetic computations more perusable
::*   eschews title-case capitalization capitalizations
::*   maintains the same line for the   '''then'''   clause and the   '''if'''   clause   (no split statements)
::*   uses indentations for all REXX statements in the function
::*   has the result on the same line as the input   (data points)
::*   a different quoted literal style   (for easier reading of multiple literals on the same clause)
::*   REXX variables to hold long literals that would otherwise cause excessive wide REXX statements
::* &nbsp; a comma &nbsp; (instead of a slash) &nbsp; to separate the &nbsp; <big> '''x &nbsp; y''' </big> &nbsp; coördinates of the data points.
::* &nbsp; elides superfluous &nbsp; '''do-end''' &nbsp; block structures; &nbsp; less clutter, easier to read
::* &nbsp; a lotadded more whitespace within some REXX statements and the REXX program's output
::* &nbsp; tests all data possibilities &nbsp; (for showing all the tested non-intersecting conditions)
::* &nbsp; for viewing the calculation in its entirity, all program logic was kept within single viewable screen
 
{{trans|REXX (version 2)}}
<lang rexx>/*REXX program finds (possibly) the intersection of two lines (with diagnostic errors).*/
Line 29 ⟶ 33:
exit /* ═══a═══ ═══b═══ ═══c═══ ═══c═══ stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
iSect: procedure; parse arg xa ya xb yb xc yc xd yd /*optain args ydfrom invocation. */
$=. d2=yc - k2 * xc /*calc.the intersection withor Yerror axismsg.*/▼
if xa=xb then do; k1=. /*the slope is infinite. end */▼
else do x1=xa /*CDthe isnX't as vertical line.intersection is XA */▼
if ycya=ydyb then $= 'points CA and DB are identical'▼
end else if k2=. then do /* [↑] AB is a /*vertical CDline. */▼
else do; k2k1=(ydyb-ycya) / (xdxb-xcxa) /*compute the slope of CDAB */▼
d1=ya - k1 * xa /*calc. intersection with endY axis*/▼
end /* [↑] AB isn't a end /*normalvertical line*/▼
if $xc=.xd then do; k2=. /*the slope is infinite. /*no special case so far ··· */▼
x2=xc /*the C's intersection is y=k1XC * x + d1/▼
if yc=yd then $= 'points C and D are else doidentical'▼
end /* [↑] CD elseis a $=@paralvertical /*parallelline. */▼
else do; k2=(yd-yc) / (xd-xc) /*compute the slope of CD */
d2=yc - y=k2 * x + d2xc /*Ycalc. fromintersection CDwith Y axis*/▼
end /* [↑] CD isn't a vertical x=(d2-d1) line*/ (k1-k2)▼
@ident= 'lines AB and CD are identical' /*literal to help shorten a line*/
@paral= 'lines AB and CD are parallel' /* " " " " " " */
$=. /*the intersection[↓] no special orcase errorso msg.far···*/
if xa$=xb. then do if k1=. then if k2=. then if x1=x2 then $=@ident /*is AB a vertical line? identical. */
k1=. /*the slope is infinite. else $=@paral /*parallel. */
x1=xa else do; x=x1 /*the X's intersection is XA /*use X1 */
if ya=yb then $ y=k2 * x + d2 'points A and B/*Y from CD are identical'*/
end
else do else if k2=. then do; x=x2 /*AB isn't a vertical line./*X from CD */
k1=(yb-ya) / (xb-xa) / y=k1 *compute thex slope+ ofd1 AB /*Y from AB */
d1=ya - k1 * xa /*calc. intersection with Y axis*/end
end else if k1=k2 then if d1=d2 then $= @ident
else $= @paral▼
 
if xc=xd then do /*is CD a vertical line? * else do; x=(d2-d1) / (k1-k2)
k2=. /*the slope is infinite. y=k1 */ x + d1
x2=xc /*the C's intersection is XC end /* [↑] normal*/
▲ if yc=yd then $= 'points C and D are identical'
end▼
▲ else do /*CD isn't a vertical line. */
▲ k2=(yd-yc) / (xd-xc) /*compute the slope of CD */
▲ d2=yc - k2 * xc /*calc. intersection with Y axis*/
end
 
▲ if $=. then do /*no special case so far ··· */
if k1=. then if k2=. then if x1=x2 then $=@ident /*identical. */
▲ else $=@paral /*parallel. */
▲ else do
x=x1 /*use X1 */
▲ y=k2 * x + d2 /*Y from CD */
▲ end
▲ else if k2=. then do /*vertical CD*/
x=x2 /*X from CD */
y=k1 * x + d1 /*Y from AB */
▲ end
else if k1=k2 then if d1=d2 then $= @ident
▲ else $= @paral
else do /*normal.*/
▲ x=(d2-d1) / (k1-k2)
▲ y=k1 * x + d1
▲ end /*normal line*/
end▼
 
if $=. then $= 'intersection is at (' || x","y')' /*$ ¬defined?*/
info@ = left( 'a=('xa","ya')', 12) left( 'b=('xb","yb')', 12), /*whitespace.*/
left( 'c=('xc","yc')', 12) left( 'd=('xd","yd')', 12) /* " */
return left(info@, max(51, length(info@) ) ) ' ───► ' $ /*return str.*/</lang>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 105 ⟶ 98:
:::: But let's agree that our taste as far as formatting is concerned is vastly different.
:::: And I added commentary to my version. --[[User:Walterpachl|Walterpachl]] ([[User talk:Walterpachl|talk]]) 09:29, 19 May 2017 (UTC)
 
== Clojure version does not handle edge case case of undefined slope (vertical line) ==
 
The part that calculates m (slope) fails if `(- x2 x1)` is zero.
(defn compute-line [pt1 pt2]
(let [[x1 y1] pt1
▲ [x2 y2] endpt2
▲ m (/ (- y2 y1) (- x2 endx1))]
{:slope m
:offset (- y1 (* m x1))}))
 
 
 
Should the clojure version do something other than throw an exception if the compute-line fn receives a vertical line like [0 0] [0 6], but also all cases like [X Y] [X Z], I would suspect.
 
Currently it just throws on divide by zero, which means you can not find the intersection if the both x-coords points of one line are the same.
 
== javascript ==
 
can we have a webpage version of the code?
:I just added an online link for a transpiled version of Phix (am currently doing that sort of thing to lots of pages), not exactly what you asked for I know, but you could use that as a starting point: rip out my p2js.js, make X=0 and Y=1, replace $subse() with plain e[X] etc, kill off all those ugly "sequence", a few "[," ==> "[", and lastly you'll need a replacement for my print(). HTH. --[[User:Petelomax|Pete Lomax]] ([[User talk:Petelomax|talk]]) 21:04, 29 December 2021 (UTC) PS Please in future sign your posts using <nowiki>--~~~~</nowiki> (without the nowiki bits).
Petelomax
7,794

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/275417...275424"