Length of an arc between two angles: Difference between revisions

{{trans|Python}}

R (360.0 - abs(angleB - angleA)) * math:pi * r / 180.0

{{out}}

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

PROC ArcLength(REAL POINTER r,a1,a2,len)

ArcLength(r,a1,a2,len)

PrintR(len)

{{out}}

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

=={{header|Ada}}==

with Ada.Numerics;

Distance_Io.Put (Arc_Length, Exp => 0, Aft => 4);

New_Line;

{{out}}

<pre>

=={{header|ALGOL W}}==

Follows the Fortran interpretation of the task and finds the length of the major arc.

% returns the length of the arc between the angles a and b on a circle of radius r %

% the angles should be specified in degrees %

% task test case %

write( r_w := 10, r_d := 4, r_format := "A", majorArcLength( 10, 120, 10 ) )

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

<pre> 10 arc 10 120

=={{header|AutoHotkey}}==

return

arcLength(radius, angle1, angle2){

return (360 - Abs(angle2-angle1)) * (π := 3.141592653589793) * radius / 180

{{out}}

<pre>43.633231</pre>

=={{header|AWK}}==

# syntax: GAWK -f LENGTH_OF_AN_ARC_BETWEEN_TWO_ANGLES.AWK

# converted from PHIX

}

function abs(x) { if (x >= 0) { return x } else { return -x } }

{{out}}

<pre>

=={{header|BASIC}}==

20 READ R, A1, A2

30 GOSUB 100

100 REM Calculate length of arc of radius R, angles A1 and A2

110 A = ATN(1)*R*(360-ABS(A1-A2))/45

{{out}}

<pre> 43.6332</pre>

=={{header|C}}==

{{Trans|AWK}}

#define PI 3.14159265358979323846

#define ABS(x) (x<0?-x:x)

printf("%.7f\n",arc_length(10, 10, 120));

}

{{out}}

<pre>

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

{{trans|Kotlin}}

#define _USE_MATH_DEFINES

std::cout << "arc length: " << al << '\n';

return 0;

{{out}}

<pre>arc length: 43.6332</pre>

=={{header|D}}==

{{trans|C++}}

import std.stdio;

void main() {

writeln("arc length: ", arcLength(10.0, 10.0, 120.0));

{{out}}

<pre>arc length: 43.6332</pre>

=={{header|Delphi}}==

{{Trans|AWK}}

program Length_of_an_arc;

Readln;

end.

{{out}}

<pre>

=={{header|Factor}}==

: arc-length ( radius angle angle -- x )

- abs deg>rad 2pi swap - * ;

{{out}}

<pre>

=={{header|FOCAL}}==

01.20 S A2=120

01.30 S R=10

02.01 C CALCULATE LENGTH OF ARC OF RADIUS R, ANGLES A1 AND A2

{{out}}

<pre>= 43.6332</pre>

=={{header|Fortran}}==

The Fortran subroutine contains the MAX(DIF, 360. - DIF) operation. Other solutions presented here correspond to different interpretations of the problem. This subroutine computes the length of the major arc, which is not necessarily equal to distance traveling counter-clockwise.

* given: polar coordinates of two points on a circle of known radius

* find: length of the major arc between these points

END

{{out}}

<pre> first angle: 120.000000 second angle: 10.0000000 radius: 10.0000000 Length of major arc: 43.6332321

=={{Header|FreeBASIC}}==

#define DEG 0.017453292519943295769236907684886127134

print arclength(10, 10, 120)

{{out}}

<pre>

=={{header|Go}}==

{{trans|Julia}}

import (

func main() {

fmt.Println(arcLength(10, 10, 120))

{{out}}

=={{header|Haskell}}==

{{Trans|Julia}}

{{out}}

<pre>arcLength 10.0 10.0 120.0 = 43.63323129985823</pre>

=={{header|Java}}==

return (360.0 - Math.abs(a2-a1))*Math.PI/180.0 * r;

=={{header|JavaScript}}==

{{Trans|AWK}}

function arc_length(radius, angle1, angle2) {

return (360 - Math.abs(angle2 - angle1)) * Math.PI / 180 * radius;

console.log(arc_length(10, 10, 120).toFixed(7));

{{out}}

In case you're wondering why `length` appears below where you might expect `abs`, rest assured that jq's `length` applied to a number yields its absolute value.

def arclength(radius; angle1; angle2):

def pi: 1 | atan * 4;

# The task:

# {{out}}

<pre>

=={{header|Julia}}==

The task seems to be to find the distance along the circumference of the circle which is NOT swept out between the two angles.

arclength(r, angle1, angle2) = (360 - abs(angle2 - angle1)) * π/180 * r

@show arclength(10, 10, 120) # --> arclength(10, 10, 120) = 43.63323129985823

=={{header|Kotlin}}==

{{trans|Go}}

import kotlin.math.abs

val al = arcLength(10.0, 10.0, 120.0)

println("arc length: $al")

{{out}}

<pre>arc length: 43.63323129985823</pre>

=={{header|Lua}}==

{{trans|D}}

return (360.0 - math.abs(angle2 - angle1)) * math.pi * radius / 180.0

end

end

{{out}}

<pre>arc length: 43.633231299858</pre>

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

MajorArcLength[r_, {a1_, a2_}] := Module[{d},

d = Mod[Abs[a1 - a2], 360];

d Degree r

]

{{out}}

<pre>43.6332</pre>

=={{header|Nim}}==

const TwoPi = 2 * Pi

result = r * (if d >= Pi: d else: TwoPi - d)

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use utf8;

[-90, 180, 10/π],

[-90, 0, 10/π],

{{out}}

<pre>Arc length: 43.63323 Parameters: (2.0943951, 0.1745329, 10.0000000)

=={{header|Phix}}==

{{trans|Julia}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">arclength</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">angle1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">angle2</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">arclength</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">120</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- 43.6332313</span>

=={{header|Python}}==

def arc_length(r, angleA, angleB):

<pre>

radius = 10

degrees to radians and a postfix ᵍ to convert gradians to radians.

( ([-] (a2, a1).map((* + τ) % τ)) + τ ) % τ × $radius

}

\(175ᵍ, -45ᵍ, :r(10/π)) { # test gradian parameters

printf "Arc length: %8s Parameters: %s\n", arc(|$_).round(.000001), $_.raku

{{out}}

<pre>Task example: from 120° counter-clockwise to 10° with 10 unit radius

This REXX version handles angles (in degrees) that may be &nbsp; <big> &gt; </big> &nbsp; 360º.

parse arg radius angle1 angle2 . /*obtain optional arguments from the CL*/

if radius=='' | radius=="," then radius= 10 /*Not specified? Then use the default.*/

arcLength: procedure; parse arg r,a1,a2; #=360; return (#-abs(a1//#-a2//#)) * pi()/180 * r

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

<pre>

=={{header|Ring}}==

decimals(7)

pi = 3.14159265

x = (360 - fabs(angle2-angle1)) * pi / 180 * radius

return x

{{out}}

<pre>

=={{header|Ruby}}==

{{trans|C}}

return (360.0 - (angle2 - angle1).abs) * Math::PI / 180.0 * radius

end

{{out}}

<pre>43.6332313</pre>

=={{header|Vlang}}==

{{trans|go}}

fn arc_length(radius f64, angle1 f64, angle2 f64) f64 {

fn main() {

println(arc_length(10, 10, 120))

{{out}}

<pre>43.633231299858</pre>

=={{header|Wren}}==

{{trans|Julia}}

{{out}}

=={{header|XPL0}}==

func real ArcLen(Radius, Angle1, Angle2); \Length of major arc of circle

RlOut(0, ArcLen(10., 10., 120.));

{{out}}

=={{header|zkl}}==

{{trans|Julia}}

(360.0 - (angle2 - angle1).abs()).toRad()*radius

}

{{out}}

<pre>