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

{{trans|Nim}}

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

=={{header|AutoHotkey}}==

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

=={{header|AWK}}==

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

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

=={{header|C}}==

#define TWO_PI 6.283185307179586

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

public static class Angles

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

{{libheader|Boost}}

#include <iostream>

#include <iomanip>

or (angles) for auto-test.

VAL* is unnormalized.

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

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

{{libheader| System.Math}}

{{Trans|Go}}

program normalization_and_conversion;

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

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

=={{header|Go}}==

import (

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

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

Test:

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

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

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

newtype Rad = Rad Double

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

The task assignment shows different possible type annotations.

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

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

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

</syntaxhighlight>

we can compose conversion sentences like

as_degree 100 Gradian

90

</syntaxhighlight>

Presuming the following additional definitions:

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

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

=={{header|Java}}==

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

</pre>

=={{header|Javascript}}==

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

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

'''Preliminaries'''

# Right-justify but do not truncate

</syntaxhighlight>

'''The Task'''

def mod($y):

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

=={{header|Julia}}==

d2d(d) = d % 360

=={{header|Kotlin}}==

{{trans|Java}}

const val DEGREE = 360.0

=={{header|Lua}}==

function convert(value, fromunit, tounit)

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

end</syntaxhighlight>

Optionally:

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

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

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

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

If[Abs[a/full] > 4,

=={{header|Nim}}==

import strformat

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

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

=={{header|Python}}==

===Python: Original===

TWO_PI = 6.283185307179586

===Python: using tkinter===

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

Angles (geometric), normalization and conversion challenge.

{{trans|Common Lisp}}

(define (rem n m)

=={{header|Raku}}==

(formerly Perl 6)

my @units =

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

''(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 - τ }

=={{header|REXX}}==

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

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

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

=={{header|Rust}}==

marker::PhantomData,

f64::consts::PI,

=={{header|Swift}}==

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

=={{header|Vlang}}==

{{trans|Go}}

import strconv

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

{{trans|Go}}

{{libheader|Wren-fmt}}

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

=={{header|XPL0}}==

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

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

=={{header|zkl}}==

{{trans|Raku}}

tau=(0.0).pi*2,

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

})

;</syntaxhighlight>

println(" Angle Unit ",

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