Shoelace formula for polygonal area: Difference between revisions

{{trans|Python}}

 

R abs(sum(zip(x, y[1..] [+] y[0.<1]).map((i, j) -> i * j))

-sum(zip(x[1..] [+] x[0.<1], y).map((i, j) -> i * j))) / 2

V y = points.map(p -> p[1])

 

 

{{out}}

 

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

SHOELACE CSECT

USING SHOELACE,R15 base register

PG DC CL12' ' buffer

REGEQU

{{out}}

<pre>

30

</pre>

 

{{works with|Ada|Ada|83}}

 

 

procedure Shoelace_Formula_For_Polygonal_Area

begin

Ada.Text_IO.Put_Line(Shoelace(my_polygon)'Img);

{{out}}

<pre> 3.00000E+01

 

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

# returns the area of the polygon defined by the points p using the Shoelace formula #

OP AREA = ( [,]REAL p )REAL:

print( ( fixed( AREA [,]REAL( ( 3.0, 4.0 ), ( 5.0, 11.0 ), ( 12.0, 8.0 ), ( 9.0, 5.0 ), ( 5.0, 6.0 ) ), -6, 2 ), newline ) )

END

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

<pre> shoelace (3 4) (5 11) (12 8) (9 5) (5 6)

30</pre>

 

=={{header|C}}==

Reads the points from a file whose name is supplied via the command line, prints out usage if invoked incorrectly.

#include<stdlib.h>

#include<stdio.h>

return 0;

}

Input file, first line specifies number of points followed by the ordered vertices set with one vertex on each line.

<pre>

=={{header|C sharp|C#}}==

{{trans|Java}}

using System.Collections.Generic;

 

}

}

{{out}}

<pre>Given a polygon with vertices [(3, 4), (5, 11), (12, 8), (9, 5), (5, 6)],

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

{{trans|D}}

#include <tuple>

#include <vector>

auto ans = shoelace(points);

cout << ans << endl;

{{out}}

<pre>30</pre>

 

=={{header|Cowgol}}==

 

typedef Coord is uint16; # floating point types are not supported

var polygon: Point[] := {{3,4},{5,11},{12,8},{9,5},{5,6}};

print_i16(shoelace(&polygon[0], @sizeof polygon));

{{out}}

<pre>30</pre>

=={{header|D}}==

 

Point[] pnts = [{3,4}, {5,11}, {12,8}, {9,5}, {5,6}];

auto ans = shoelace(pnts);

assert(ans == 30);

{{out}}

<pre>30</pre>

 

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

// Shoelace formula for area of polygon. Nigel Galloway: April 11th., 2018

let fN(n::g) = abs(List.pairwise(n::g@[n])|>List.fold(fun n ((nα,gα),(nβ,gβ))->n+(nα*gβ)-(gα*nβ)) 0.0)/2.0

{{out}}

<pre>

=={{header|Factor}}==

By constructing a <code>circular</code> from a sequence, we can index elements beyond the length of the sequence, wrapping around to the beginning. We can also change the beginning of the sequence to an arbitrary index. This allows us to use <code>2map</code> to cleanly obtain a sum.

IN: rosetta-code.shoelace

 

[ shoelace-sum ] 2bi@ - abs 2 / ;

 

{{out}}

<pre>

Except for the use of "END FUNCTION ''name'' instead of just END, and the convenient function SUM with array span expressions (so SUM(P) rather than a DO-loop to sum the elements of array P), both standardised with F90, this would be acceptable to F66, which introduced complex number arithmetic. Otherwise, separate X and Y arrays would be needed, but complex numbers seemed convenient seeing as (x,y) pairs are involved. But because the MODULE facility of F90 has not been used, routines invoking functions must declare the type of the function names, especially if the default types are unsuitable, as here. In function AREA, the x and y parts are dealt with together, but in AREASL they might be better as separate arrays, thus avoiding the DIMAG and DBLE functions to extract the x and y parts. Incidentally, the x and y parts can be interchanged and the calculation still works. Comparing the two resulting areas might give some indication of their accuracy.

 

C Uses the mid-point rule for integration. Consider the line joining (x1,y1) to (x2,y2)

C The area under that line (down to the x-axis) is the y-span midpoint (y1 + y2)/2 times the width (x2 - x1)

A2 = AREASL(5,POINT)

WRITE (6,*) "A=",A1,A2

 

Output: WRITE (6,*) means write to output unit six (standard output) with free-format (the *). Note the different sign convention.

===Fortran I===

In orginal FORTRAN 1957:

C SHOELACE FORMULA FOR POLYGONAL AREA

DIMENSION X(33),Y(33)

303 FORMAT(F10.2)

 

{{in}}

<pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>The area of the polygon = 30</pre>

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

import "fmt"

func main() {

fmt.Println(shoelace([]point{{3, 4}, {5, 11}, {12, 8}, {9, 5}, {5, 6}}))

{{out}}

<pre>

 

=={{header|Haskell}}==

 

 

shoelace :: [(Double, Double)] -> Double

shoelace =

{{out}}

<pre>30.0</pre>

Implementation:

 

0.5*|+/((* 1&|.)/ - (* _1&|.)/)|:y

 

Task example:

 

 

Exposition:

We start with our list of coordinate pairs

 

3 4

5 11

12 8

9 5

 

But the first thing we do is transpose them so that x coordinates and y coordinates are the two items we are working with:

 

3 5 12 9 5

 

We want to rotate the y list by one (in each direction) and multiply the x list items by the corresponding y list items. Something like this, for example:

 

 

Or, rephrased:

 

 

We'll be subtracting what we get when we rotate in the other direction, which looks like this:

 

 

Finally, we add up that list, take the absolute value (there are contexts where signed area is interesting - for example, some graphics application - but that was not a part of this task) and divide that by 2.

{{trans|Kotlin}}

{{works with|Java|9}}

 

public class ShoelaceFormula {

System.out.printf("its area is %f,%n", area);

}

{{out}}

<pre>Given a polygon with vertices [(3, 4), (5, 11), (12, 8), (9, 5), (5, 6)],

 

=={{header|JavaScript}}==

 

// shoelaceArea :: [(Float, Float)] -> Float

const shoeLaceArea = vertices => abs(

uncurry(subtract)(

)

)

[5, 6]

];

};

 

 

// abs :: Num -> Num

 

 

const ap = f =>

// Applicative instance for functions.

// compose (<<<) :: (b -> c) -> (a -> b) -> a -> c

const compose = (...fs) =>

fs.reduce(

(f, g) => x => f(g(x)),

 

// cycle :: [a] -> Generator [a]

const lng = xs.length;

let i = 0;

while (true) {

i = (1 + i) % lng;

}

 

 

// length :: [a] -> Int

// the shorter argument when one is non-finite,

// like cycle, repeat etc

xs.length

) : Infinity;

 

 

// A new list consisting of all

// items of xs except the first.

) : (take(1)(xs), xs);

 

// The first n elements of a list,

// string of characters, or stream.

.constructor.constructor.name ? (

xs.slice(0, n)

length: n

}, () => {

const x = xs.next();

return x.done ? [] : [x.value];

 

 

// A function over a pair, derived

// from a curried function.

};

 

 

 

 

 

// MAIN ---

return main();

{{Out}}

<pre>Polygonal area by shoelace formula:

[[3,4],[5,11],[12,8],[9,5],[5,6]] -> 30</pre>

 

=={{header|Julia}}==

{{trans|Python}}

 

Assumes x,y points go around the polygon in one direction.

"""

 

x, y = [3, 5, 12, 9, 5], [4, 11, 8, 5, 6]

 

{{out}}

 

=={{header|Kotlin}}==

 

class Point(val x: Int, val y: Int) {

println("Given a polygon with vertices at $v,")

println("its area is $area")

 

{{out}}

 

=={{header|Lambdatalk}}==

{def shoelace

{lambda {:pol}

{shoelace {pol}}

-> 30

 

=={{header|Lua}}==

local function det2(i,j)

return ps[i][1]*ps[j][2]-ps[j][1]*ps[i][2]

for i=1,#ps-1 do sum = sum + det2(i,i+1)end

return math.abs(0.5 * sum)

Using an accumulator helper inner function

local function ssum(acc, p1, p2, ...)

if not p2 or not p1 then

 

local p = {{3,4}, {5,11}, {12,8}, {9,5}, {5,6}}

both version handle special cases of less than 3 point as 0 area result.

 

=={{header|Maple}}==

 

with(ArrayTools):

 

P1 := Polygon(Array([Point(3,4), Point(5,11), Point(12,8), Point(9,5), Point(5,6)])):

area(P1);

 

{{out}}<pre>

</pre>

 

Geometry objects built-in in the Wolfram Language

{{out}}

<pre>30</pre>

=={{header|min}}==

{{works with|min|0.19.3}}

(((first) (rest)) cleave append) :rotate

((0 <) (-1 *) when) :abs

) :shoelace

 

{{out}}

<pre>

 

=={{header|MiniScript}}==

sum = 0

points = vertices.len

 

print "The polygon area is " + shoelace(verts)

{{out}}

<pre>

 

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

FROM RealStr IMPORT RealToStr;

FROM FormatString IMPORT FormatString;

 

ReadChar;

 

=={{header|Nim}}==

Point = tuple

x: float

var points = [(3.0, 4.0), (5.0, 11.0), (12.0, 8.0), (9.0, 5.0), (5.0, 6.0)]

 

 

{{out}}

 

=={{header|Perl}}==

use warnings;

use feature 'say';

say area_by_shoelace( [ [3,4], [5,11], [12,8], [9,5], [5,6] ] );

say area_by_shoelace( @poly );

{{out}}

<pre>30

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

An alternative solution, which does not need the X,Y enum, and gives the same output:

 

=={{header|PowerBASIC}}==

{{Trans|Visual Basic}}

#DIM ALL

#COMPILER PBCC 6

CON.PRINT STR$(ShoelaceArea(x(), y()))

CON.WAITKEY$

{{out}}

<pre>30</pre>

 

=={{header|Python}}==

"Assumes x,y points go around the polygon in one direction"

return abs( sum(i * j for i, j in zip(x, y[1:] + y[:1]))

30.0

>>>

# Even simpler:

# In python we can take an advantage of that x[-1] refers to the last element in an array, same as x[N-1].

# before applying the Shoelace formula.

 

 

{{Trans|Haskell}}

{{Works with|Python|3.7}}

 

from itertools import cycle, islice

 

if __name__ == '__main__':

{{Out}}

<pre>Polygonal area by shoelace formula:

[(3, 4), (5, 11), (12, 8), (9, 5), (5, 6)] -> 30.0</pre>

 

=={{header|Racket}}==

 

(struct P (x y))

 

(module+ main

 

{{out}}

{{works with|Rakudo|2017.07}}

 

(^@p).map({@p[$_;0] * @p[($_+1)%@p;1] - @p[$_;1] * @p[($_+1)%@p;0]}).sum.abs / 2

}

 

{{out}}

<pre>30</pre>

===Slice and rotation===

{{works with|Rakudo|2017.07}}

my @x := @p».[0];

my @y := @p».[1];

 

say area-by-shoelace( [ (3,4), (5,11), (12,8), (9,5), (5,6) ] );

{{out}}

<pre>30</pre>

 

=={{header|REXX}}==

===endpoints as exceptions===

parse arg pts; $polygon = 'polygon area of ' /*get optional args from the CL.*/

if pts='' then pts= '(3,4),(5,11),(12,8),(9,5),(5,6)' /*Not specified? Use default. */

A=A + x.j * (y.jp - y.jm) /*compute a part of the area. */

end /*j*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

polygon area of 5 points: (3,4),(5,11),(12,8),(9,5),(5,6) is ───► 30

</pre>

 

 

===somewhat simplified===

reformatted and suitable for ooRexx. (x.0 etc. not needed)

parse arg pts /*obtain optional arguments from the CL*/

if pts='' then pts= '(3,4),(5,11),(12,8),(9,5),(5,6)' /*Not specified? Use default. */

end

A=abs(A/2) /*obtain half of the ¦ A ¦ sum*/

{{out}}

<pre>polygon area of 5 points: (3,4),(5,11),(12,8),(9,5),(5,6) is ---> 30</pre>

===even simpler===

Using the published algorithm

parse arg pts /*obtain optional arguments from the CL*/

if pts='' then pts= '(3,4),(5,11),(12,8),(9,5),(5,6)' /*Not specified? Use default. */

a=a+x.n*y.1-x.1*y.n

a=abs(a)/2

{{out}}

<pre>polygon area of 5 points: (3,4),(5,11),(12,8),(9,5),(5,6) is ---> 30</pre>

 

=={{header|Ring}}==

# Project : Shoelace formula for polygonal area

 

sum = sum - p[1][1] * p[i][2]

return fabs(sum) / 2

Output:

<pre>

The area of the polygon = 30

</pre>

 

=={{header|Ruby}}==

Point = Struct.new(:x,:y) do

 

 

puts Polygon.new([3,4], [5,11], [12,8], [9,5], [5,6]).area # => 30.0

 

=={{header|Scala}}==

 

case class Polygon( pp:List[Point] ) {

println( "Area of " + p + " = " + p.area )

}

{{out}}

<pre>Area of Polygon( (3,4), (5,11), (12,8), (9,5), (5,6) ) = 30.0</pre>

=={{header|Sidef}}==

{{trans|Raku}}

var x = p.map{_[0]}

var y = p.map{_[1]}

}

 

{{out}}

<pre>

{{trans|Scala}}

 

 

struct Point {

])

 

 

{{out}}

=={{header|TI-83 BASIC}}==

{{works with|TI-83 BASIC|TI-84Plus 2.55MP}}

Dim([A])->N:0->A

For(I,1,N)

A+[A](I,1)*[A](J,2)-[A](J,1)*[A](I,2)->A

End

{{out}}

<pre>

 

=={{header|VBA}}==

Public Enum axes

u = 1

Next i

Debug.Print shoelace(tcol)

<pre>30</pre>

 

=={{header|VBScript}}==

Dim points, x(),y()

points = Array(3,4, 5,11, 12,8, 9,5, 5,6)

Next 'i

area = Abs(area)/2

{{out}}

<pre>

{{works with|VBA|6.5}}

{{works with|VBA|7.1}}

 

Public Function ShoelaceArea(x() As Double, y() As Double) As Double

Next i

Debug.Print ShoelaceArea(x(), y())

{{out}}

<pre>30</pre>

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

{{trans|C#}}

 

Imports Point = System.Tuple(Of Double, Double)

End Sub

 

{{out}}

<pre>Given a polygon with vertices [(3, 4), (5, 11), (12, 8), (9, 5), (5, 6)],

 

=={{header|Wren}}==

var area = 0

for (i in 0...pts.count-1) {

 

var pts = [ [3, 4], [5, 11], [12, 8], [9, 5], [5, 6] ]

 

{{out}}

 

=={{header|XPL0}}==

int N, X, Y;

int S, I;

];

 

 

{{out}}

=={{header|zkl}}==

By the "book":

xs,ys:=Utils.Helpers.listUnzip(points); // (x,x,...), (y,y,,,)

( xs.zipWith('*,ys[1,*]).sum(0) + xs[-1]*ys[0] -

xs[1,*].zipWith('*,ys).sum(0) - xs[0]*ys[-1] )

.abs().toFloat()/2;

or an iterative solution:

xs,ys:=Utils.Helpers.listUnzip(points); // (x,x,...), (y,y,,,)

N:=points.len();

N.reduce('wrap(s,n){ s + xs[n]*ys[(n+1)%N] - xs[(n+1)%N]*ys[n] },0)

.abs().toFloat()/2;

areaByShoelace(points).println();

{{out}}

<pre>