Angles (geometric), normalization and conversion: Difference between revisions

:::*   deg

:::*   º       (a symbol)

 

 

:::*   gon(s)

:::*   metric degree(s)

 

 

:*   '''-2   -1   0   1   2   6.2831853   16   57.2957795   359   399   6399   1000000'''

<br><br>

 

=={{header|AWK}}==

# syntax: GAWK -f ANGLES_(GEOMETRIC)_NORMALIZATION_AND_CONVERSION.AWK

# gawk starts showing discrepancies at test case number 7 when compared with C#

function radian2gradian(angle) { return(angle * 200 / pi) }

function radian2mil(angle) { return(angle * 3200 / pi) }

{{out}}

<pre>

1000000 5.92562 radian 16042.8 0 1.62975e+006 5.92562 12

</pre>

 

=={{header|C}}==

#define TWO_PI 6.283185307179586

 

double rad2deg(double a) {return a * 180 / PI;}

double rad2grad(double a) {return a * 200 / PI;}

 

 

public static class Angles

public static double RadToGrad(double angle) => angle * 200 / Math.PI;

public static double RadToMil(double angle) => angle * 3200 / Math.PI;

{{out}}

<pre style="height:30ex;overflow:scroll">

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

{{libheader|Boost}}

#include <iostream>

#include <iomanip>

 

return 0;

{{out}}

<pre> ┌───────────────────┐

or (angles) for auto-test.

VAL* is unnormalized.

(defun GradToGrad (a) (rem a 400))

(defun MilToMil (a) (rem a 6400))

(format t "Grad | ~15f | ~15f | ~15f | ~15f | ~15f~%" a (GradToDeg a) (GradToGrad a) (GradToMil a) (GradToRad a))

(format t "Mil | ~15f | ~15f | ~15f | ~15f | ~15f~%" a (MilToDeg a) (MilToGrad a) (MilToMil a) (MilToRad a))

{{out}}

<pre>[CLISP]> (angles)

Mil | 1000000.0 | 90.0 | 100.0 | 1600.0 | 1.5707963267949

Rad | 1000000.0 | 339.51308232088 | 377.23675813431 | 6035.7881301489 | 5.9256211400939</pre>

 

=={{header|Factor}}==

Radians and degrees are already defined in the <code>units.si</code> vocabulary. Gradiens and mils are defined in terms of degrees. Conversions from unit to unit are handled by inverse functions; <code>[undo]</code> knows how to deconstruct units in terms of other units. (Assuming, of course, new units are defined entirely with words that have inverses.)

math.constants quotations qw sequences units.si ;

IN: rosetta-code.angles

units [ .row ] cartesian-each ;

 

{{out}}

<pre>

1000000 radians 339.5131 377.2368 6035.7881 5.9256

</pre>

 

=={{header|Go}}==

 

import (

fmt.Printf(ft, s(a), s(r2r(a)), s(r2d(a)), s(r2g(a)), s(r2m(a)))

}

 

{{out}}

=={{header|Groovy}}==

This solution creates the concept of an angular quantity with subclasses for different units of measure. Rather than creating individual functions (d2d, r2m, etc.) this solution uses inheritance, polymorphism, and operator overloading to implement the conversions and comparisons in a relatively natural way for idiomatic Groovy.

 

abstract class Angle implements Comparable<? extends Angle> {

String unitName() { UNIT }

Radians(Number value = 0) { super(value) }

 

This category class allows Angles to interoperate more easily with Numbers:

static Degrees getDeg(Number n) { new Degrees(n) }

static Gradians getGrad(Number n) { new Gradians(n) }

static Mils getMil(Number n) { new Mils(n) }

static Radians getRad(Number n) { new Radians(n) }

 

Test:

 

[ -2, -1, 0, 1, 2, 6.2831853, 16, 57.2957795, 359, 399, 6399, 1000000 ].each { rawAngle ->

assert 360.deg == 0.deg

assert 90.deg == 100.grad

 

{{out}}

1000000 1600.00000000 mil 90.00000000º 100.00000000 grad 1600.00000000 mil 1.57079633 rad

1000000 5.92562114 rad 339.51308232º 377.23675814 grad 6035.78813019 mil 5.92562114 rad</pre>

 

=={{header|J}}==

given definitions which convert to and from the unit circle, using verbial power (^:) inverse (^: _1), and adverbs to make the sentences read better? or at least differently from other computer languages:

TAU =: 2p1 NB. tauday.com

 

Mil =: adverb def 'normalize as_mil inv m'

Radian =: adverb def 'normalize as_radian inv m'

we can compose conversion sentences like

as_degree 100 Gradian

90

Presuming the following additional definitions:

NAMES =: > turn`degree`gradian`mil`radian

ALL =: as_turn`as_degree`as_gradian`as_mil`as_radian

|radian | _2 _1 0 1 2 6.28319 3.43363 0.747112 0.858437 3.15933 2.71736 5.92562|

+-------+---------------------------------------------------------------------------------------------------+

 

=={{header|Java}}==

 

// Title: Angles (geometric), normalization and conversion

}

 

{{out}}

1000000.000000 radians = 339.5131 377.2368 6035.7881 5.9256

</pre>

 

=={{header|Julia}}==

 

d2d(d) = d % 360

 

testconversions([-2, -1, 0, 1, 2, 6.2831853, 16, 57.2957795, 359, 399, 6399, 1000000])

<pre>

Number Units Degrees Gradians Mils Radians

1000000 radians 339.5130823 377.2367581 6035.7881302 5.9256211

</pre>

 

=={{header|Kotlin}}==

{{trans|Java}}

 

const val DEGREE = 360.0

println("%15s %8s = %10s %10s %10s %10s".format(fa.format(a), units, fc.format(d), fc.format(g), fc.format(m), fc.format(r)))

}

{{out}}

See Java output

 

=={{header|Lua}}==

function convert(value, fromunit, tounit)

return math.fmod(value * range[tounit] / range[fromunit], range[tounit])

print(string.format("%15.7f %8s = %15.7f %15.7f %15.7f %15.7f", value, fromunit, d, g, m, r))

end

Optionally:

assert(convert(-360,"degrees","degrees") == 0.0)

assert(convert(360,"degrees","degrees") == 0.0)

function r2g(n) return convert(n,"radians","gradians") end

function r2m(n) return convert(n,"radians","mils") end

{{out}}

<pre> VALUE UNIT = DEGREES GRADIANS MILS RADIANS

1000000.0000000 mils = 90.0000000 100.0000000 1600.0000000 1.5707963

1000000.0000000 radians = 339.5130823 377.2367581 6035.7881302 5.9256211</pre>

 

=={{header|Nim}}==

import strformat

 

echo "———————————————————————————————————————————————————————————————————————————————————"

for val in Values:

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

printf '%10g %-8s' . '%12g'x4 . "\n", $angle, ${$from}{name}, @results;

}

{{out}}

<pre> Angle Unit Degrees Gradians Mills Radians

=={{header|Phix}}==

Obviously if preferred you could define a long list of routines such as function d2g(atom a) return remainder(a/360,1)*400 end function

{{out}}

<pre>

 

=={{header|Python}}==

TWO_PI = 6.283185307179586

 

def rad2deg(a): return a * 180.0 / PI

def rad2grad(a): return a * 200.0 / PI

 

=={{header|Racket}}==

{{trans|Common Lisp}}

 

 

(define (rem n m)

(displayln

(string-join (map report-angle '(-2 -1 0 1 2 6.2831853 16 57.2957795 359 399 6399 1000000))

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

my @units =

{ code => 'd', name => 'degrees' , number => 360 },

@results .fmt('%11g');

}

{{out}}

<pre> Angle Unit Degrees Gradians Mills Radians

''(Much of the complexity is due to the requirement that negative angles must normalize to a negative number.)''

 

sub postfix:<d>( $d ) { my $a = $d % 360 * τ / 360; $d >=0 ?? $a !! $a - τ }

sub postfix:<g>( $g ) { my $a = $g % 400 * τ / 400; $g >=0 ?? $a !! $a - τ }

|($a.&f->t, $a.&f->d, $a.&f->g, $a.&f->m, $a.&f->r)».round(.00000001);

}

 

<pre> Quantity Unit turns degrees gradians mils radians

 

=={{header|REXX}}==

numeric digits length( pi() ) - length(.) /*use the "length" of pi for precision.*/

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

say center(#o,23 ) center(@n #o,w7) center(#a,w7 ) center(#b,w7 ) center(#c,w7 )

say center('',23,_) center('',w7, _) center('',w7,_) center('',w7,_) center('',w7,_)

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

<pre>

=={{header|Ruby}}==

This Angles module responds to methods like r2d. Adding an element (like "h"=>24, for a clock-like angle system) to the BASES hash adds 9 more methods, totaling to 25 methods. None of these methods are actually implemented.

BASES = {"d" => 360, "g" => 400, "m" => 6400, "r" => Math::PI*2 ,"h" => 24 }

puts

end

{{out}}

<pre style="height:45ex"> d g m r h

 

=={{header|Rust}}==

marker::PhantomData,

f64::consts::PI,

print_angles::<Mils>();

print_angles::<Radians>();

{{out}}

<pre style="height:30ex;overflow:scroll">

=={{header|Swift}}==

 

 

func normalize(_ f: Double, N: Double) -> Double {

 

print()

 

{{out}}

("1000000.0000", "1600.0000", "Mils", "90.0000", "100.0000", "1600.0000", "1.5708")

("1000000.0000", "5.9256", "Radians", "339.5132", "377.2368", "6035.7895", "5.9256")</pre>

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var d2d = Fn.new { |d| d % 360 }

for (a in angles) {

Fmt.print(f2, a, r2r.call(a), r2d.call(a), r2g.call(a), r2m.call(a))

 

{{out}}

6399.0 2.7173573 155.6931042 172.992338 2767.8774082

1000000.0 5.9256211 339.5130823 377.2367581 6035.7881302

</pre>

 

=={{header|zkl}}==

{{trans|Raku}}

tau=(0.0).pi*2,

units=Dictionary( // code:(name, units in circle)

})

})

println(" Angle Unit ",

codes.apply(fcn(k){ units[k][0] }).apply("%11s".fmt).concat(" "));

r.apply("%12g".fmt).concat(" ")));

}

{{out}}

<pre style="height:45ex">