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

{{trans|Nim}}

F normd(x) {R fmod(x, 360)}

print(‘───────────────────────────────────────────────────────────────────────────────────’)

L(val) values

{{out}}

=={{header|AutoHotkey}}==

result .= "Degrees Degrees Gradians Mils Radians`n"

return Rad2Rad(Rad) * 3200 / (π:=3.141592653589793)

}

{{out}}

<pre>Degrees Degrees Gradians Mils Radians

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

=={{header|C}}==

#define TWO_PI 6.283185307179586

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

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

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

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)

{{libheader| System.Math}}

{{Trans|Go}}

program normalization_and_conversion;

writeln(format(ft, [s(a), s(r2r(a)), s(r2d(a)), s(r2g(a)), s(r2m(a))]));

readln;

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

=={{header|FreeBASIC}}==

Provides a single function that does the normalising and converting. Supports D, G, M, R, T for degrees, gradians, mils, radians, and turns respectively.

#define INVALID -99999

next i

next k

{{out}}

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

Isomorphims between all angular types are defined via representation as turns, according to the fact that they all form the same topological space, isomorphic to open interval (-1, 1).

{-# LANGUAGE TypeApplications #-}

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

to :: forall b a. (Angle a, Angle b) => a -> b

'''Instances of different angular units.'''

newtype Rad = Rad Double

deriving (Eq, Ord, Num, Real, Fractional, RealFrac, Floating)

toTurn = toTurn @Rad . angle . atan . value

fromTurn = angle . tan . value . fromTurn @Rad

'''Examples'''

The task assignment shows different possible type annotations.

let xs = [-2, -1, 0, 1, 2, 6.2831853,

16, 57.2957795, 359, 399, 6399, 1000000]

print $ (from :: Grad -> Mil) . angle <$> xs

print $ (from :: Mil -> Mil) . angle <$> xs

<pre>λ> main

Mil =: adverb def 'normalize as_mil inv m'

Radian =: adverb def 'normalize as_radian inv m'

we can compose conversion sentences like

<lang>

as_degree 100 Gradian

90

Presuming the following additional definitions:

<lang>

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

</pre>

=={{header|Javascript}}==

/*****************************************************************\

| Expects an angle, an origin unit and a unit to convert to, |

}

}

Output (without bolds and subs):

{{out}}<pre>

'''Preliminaries'''

# Right-justify but do not truncate

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

'''The Task'''

def mod($y):

(if . < 0 then -$y else 0 end) as $adjust

task2, "",

task3, "",

{{out}}

<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

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

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

NormalizeAngle[d_, full_] := Module[{a = d},

If[Abs[a/full] > 4,

Mil2Gradian, Mil2Radian, Radian2Degree, Radian2Gradian,

Radian2Mil}, {-2, -1, 0, 1, 2, 6.2831853, 16, 57.2957795, 359, 399,

{{out}}

<pre>{-(20/9),-(160/9),0,9/10,32,0.098696,9/10,3.58099,(359 \[Pi])/3200,71820/\[Pi],1279800/\[Pi],3200000000/\[Pi]}</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

<span style="color: #008080;">constant</span> <span style="color: #000000;">units</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"degrees"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"gradians"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"mils"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"radians"</span><span style="color: #0000FF;">},</span>

<span style="color: #000000;">turns</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">/</span><span style="color: #000000;">360</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">/</span><span style="color: #000000;">400</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">/</span><span style="color: #000000;">6400</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0.5</span><span style="color: #0000FF;">/</span><span style="color: #004600;">PI</span><span style="color: #0000FF;">}</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>

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

{{out}}

<pre>

=={{header|Python}}==

===Python: Original===

TWO_PI = 6.283185307179586

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

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

===Python: using tkinter===

''' Python 3.6.5 code using Tkinter graphical user interface.

Angles (geometric), normalization and conversion challenge.

## results matched those from a few other languages on this

## page.

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

=={{header|Vlang}}==

{{trans|Go}}

import strconv

fn d2d(d f64) f64 { return math.mod(d, 360) }

println('${s(a)} ${s(r2r(a))} ${s(r2d(a))} ${s(r2g(a))} ${s(r2m(a))}')

}

{{out}}

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

=={{header|XPL0}}==

func real D2D; real D; return Mod(D, 360.);

func real G2G; real G; return Mod(G, 400.);

RlOut(0, R2M(Angle(I))); CrLf(0);

];

{{out}}

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