Old Russian measure of length: Difference between revisions

:<code>commandname <value> <unit></code>

 

‘fut’ = 0.3048, ‘kilometer’ = 1000.0, ‘liniya’ = 0.00254,

‘meter’ = 1.0, ‘milia’ = 7467.6, ‘piad’ = 0.1778,

print(‘#. #. to:’.format(value, unit))

L(unt, mlt) sorted(unit2mult.items())

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Real Math}}

 

DEFINE PTR="CARD"

PrintResult(value,unit)

OD

{{out}}

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

240000 vershoks

10 versts

</pre>

 

===Vanilla===

 

on convertLinear(inputNumber, inputUnitRecord, outputUnitRecord)

set {inputType, outputType} to {inputUnitRecord's type, outputUnitRecord's type}

end demo

 

 

{{output}}

1000 metres; 100000 centimetres; 1 kilometre; 2.249718785152E+4 vershoks; 1406.07424072 arshins; 468.69141357 sazhens; 0.93738283 verstas

1 versta is:

 

===AppleScriptObjC===

 

use framework "Foundation"

use scripting additions

end demo

 

 

{{output}}

1,000 metres; 100,000 centimetres; 1 kilometre; 22,497.188 vershoks; 1,406.074 arshins; 468.691 sazhens; 0.937 verstas

1 versta is:

 

=={{header|AWK}}==

# syntax: GAWK -f OLD_RUSSIAN_MEASURE_OF_LENGTH.AWK

BEGIN {

printf("error: invalid measure; choose from: %s\n\n",units)

}

{{out}}

<pre>

</pre>

 

@% = &90E

PROColdrus(1, "meter")

NEXT

ENDIF

{{out}}

<pre>1 meter =

2800 liniya

28000 tochka</pre>

 

=={{header|C}}==

Accepts length and unit as input, prints out length in all other units. Usage printed on incorrect invocation.

#include<string.h>

#include<stdlib.h>

return 0;

}

Output :

<pre>

 

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

#include <iostream>

#include <iomanip>

}

//-------------------------------------------------------------------------------------------

Output:

<pre>

=={{header|D}}==

{{trans|Raku}}

 

void main(in string[] args) {

foreach (immutable key; factor.keys.schwartzSort!(k => factor[k]))

writefln("%10s: %s", key, meters / factor[key]);

{{out}}

<pre>1 meter to:

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Old_Russian_measure_of_length;

 

readln(yn);

until yn.toLower = 'n';

 

=={{header|Elena}}==

{{trans|Julia}}

import system'routines;

import extensions;

{

if (program_arguments.Length != 3)

real value := program_arguments[1].toReal();

{

console.printLine("only following units are supported:",

AbortException.raise()

console.printLine(value," ",unit," to:");

 

{

console.printPaddingLeft(30, u, ":").printLine(value * unit2mult[unit] / mlt)

}

{{out}}

<pre>2.3 meter to:

=={{header|Factor}}==

This solution makes use of Factor's rather robust <code>units</code> vocabulary. Units may be defined in terms of any unit and converted to any unit through the power of inverse functions (via the <code>inverse</code> vocabulary). This means that we also have access to a variety of units defined in <code>units.si</code>, <code>units.imperial</code>, etc.

sequences units.imperial units.si vocabs ;

IN: rosetta-code.units.russian

PRIVATE>

 

{{out}}

<pre>

 

=={{header|Fortran}}==

IMPLICIT NONE

REAL, PARAMETER:: E_m = 1.

WRITE (*, '(F20.3, " ", A)') RD_V / wert(J), nam(J)

END DO

{{out}}

<pre>m mm km cm arshin fut piad vershok dyuim liniya tochka ladon lokot sazhen versta milya

10.000 arshin</pre>

 

=={{header|Forth}}==

Tested with GForth.

create values 1000.0e f, 1.0e f, 0.01e f, 0.000254e f, 0.00254e f, 0.0254e f, 0.04445e f, 0.1778e f, 0.3048e f, 0.7112e f, 2.1336e f, 1066.8e f, 7467.6e f,

: unit ( u1 -- caddr u1 )

1e s" meter" show

20e s" versta" show

{{out}}

<pre>

=={{header|Frink}}==

One of Frink's unique features is tracking units of measure through all calculations. It is easy to add new units of measure and allow them to be automatically converted between any existing units. Frink's standard data file contains 642 units of length (not including prefixes) that this program can convert between.

vershok := 1/16 arshin

sazhen := 3 arshin

println[" " + (val -> "meters")]

println[" " + (val -> "centimeters")]

{{out}}

<pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

}

}

 

{{out}}

=={{header|Haskell}}==

 

 

import Text.Printf (printf)

(_) -> do

name <- getProgName

 

Output:

=={{header|J}}==

Translation of python.

 

else.

else.

end.

end.

end.

)

<pre>

8 meter to:

┌──────────┬──────────┐

│versta │0.00749906│

└──────────┴──────────┘

</pre>

 

=={{header|Java}}==

 

final static String[] keys = {"tochka", "liniya", "centimeter", "diuym",

return Double.NaN;

}

 

<pre>1 meter to:

versta: 7,00000

milia: 1,00000</pre>

 

=={{header|Julia}}==

{{trans|Python}}

 

 

const unit2mult = Dict(

for (unt, mlt) in sort(unit2mult)

@printf(" %10s: %g\n", unt, value * unit2mult[unit] / mlt)

 

{{out}}

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

/* clears console on Windows 10 */

}

while (yn == "y")

Sample input/output

{{out}}

 

Do another one y/n : n

</pre>

 

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

These units are built-in to Wolfram Language:

units = {"RussianVershoks", "RussianArshins", "RussianSazhens", "RussianVerstas", "Centimeters", "Meters", "Kilometers"};

ConvertRussianQuantities[q_Quantity] := UnitConvert[q, #] & /@ Select[units, QuantityUnit[q] != # &]

ConvertRussianQuantities[Quantity[1, "Vershoks"]]

{{out}}

<pre>{1/16 Russian arshins, 1/48 Russian sazhens, 1/24000 Russian versts, 889/200 cm, 889/20000 m, 889/20000000 km}

 

=={{header|МК-61/52}}==

П9 ИП7 1 0 6 7 / П0 5 0

0 * ПC 3 * ПA 1 6 * ПB

С/П ПB 1 6 / ПA 3 / ПC 5

0 0 / П0 1 0 6 7 / БП

 

''Instruction:''

=={{header|Nim}}==

{{trans|Python}}

 

const Unit2Mult = {"arshin": 0.7112, "centimeter": 0.01, "diuym": 0.0254,

echo value, ' ', unit, " to:"

for (key, mult) in Unit2Mult.pairs:

 

{{out}}

Displaying converted values to 5 significant digits.

{{trans|Raku}}

my($magnitude, $unit) = @_;

my %factor = (

 

print convert(1,'meter'), "\n\n";

{{out}}

<pre> tochka: 3937.0

 

=={{header|Phix}}==

{{out}}

<pre>

:<code>commandname <value> <unit></code>

 

unit2mult = {"arshin": 0.7112, "centimeter": 0.01, "diuym": 0.0254,

print("%g %s to:" % (value, unit))

for unt, mlt in sorted(unit2mult.items()):

 

{{out}}

=={{header|Racket}}==

Follows the Raku solution, produces similar output.

#lang racket

 

(show 'meter)

(show 'milia)

 

=={{header|Raku}}==

Fairly straightfoward. Define a hash of conversion factors then apply them. Makes no attempt to do correct pluralization because I have no idea what the correct plurals are and little interest in researching them. Conversion factors from Wikipedia: [[wp:Obsolete_Russian_units_of_measurement#Length|Obsolete Russian units of measurement]].

 

 

say '*' x 40, "\n";

for %factor.keys.sort:{ +%factor{$_} }

}

 

<pre>

::* &nbsp; uses the correct length unit names when not plural

::* &nbsp; columnarized the output &nbsp; (instead of a horizontal stream).

numeric digits 200 /*lots of digits. */

/*──translation───*/

err: say center(' error ', sw % 2, "*"); do j=1 to arg(); say arg(j); end; exit 13

s: if arg(1)=1 then return arg(3); return word( arg(2) 's', 1) /*plurals.*/

This REXX program makes use of &nbsp; '''LINESIZE''' &nbsp; REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console).

 

 

=={{header|Ring}}==

# Project : Old Russian measure of length

 

end

end

Output:

<pre>

</pre>

 

=={{header|Ruby}}==

 

RATIOS =

# 13*13 = 169 methods supported, but not:

p Distances.mile2piad(1)

{{out}}

<pre>2 meter =

:<code>commandname <value> <unit></code>

 

use std::process;

use std::collections::HashMap;

 

}

<pre>

$ ./oldrus test

 

=={{header|Scala}}==

 

object OldRussianLengths extends App {

} else println("Please provide a number and unit on the command line.")

 

 

=={{header|Sidef}}==

{{trans|Raku}}

var factor = Hash(

tochka => 0.000254,

convert(1, 'meter')

say('')

{{out}}

<pre>1 meter to:

Tcllib already has a [http://core.tcl.tk/tcllib/doc/trunk/embedded/www/tcllib/files/modules/units/units.html units] package which knows about a lot of things, and can be taught more. Since the other examples in this page provide a nicely tabulated conversions for 1 meter, we can copy that directly to get started ...

 

package require units

 

add_russian_units

demo

 

{{out}}

One nice side effect of this implementation is that units can work with more complex dimensions:

 

% units::convert "1 piad^2" "hectare"

3.1612805858160454e-6

% units::convert "100 km/h" "versta/minute"

1.562305

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

{{libheader|Wren-str}}

 

var units = [

if (yn == "n") break

System.print()

 

{{out}}

centimeter : 10000.0

meter : 100.0

 

Do another one y/n : n