Temperature conversion: Difference between revisions

 

=={{header|11l}}==

print(‘K ’k)

print(‘C ’(k - 273.15))

print(‘F ’(k * 1.8 - 459.67))

 

{{out}}

Use of packed decimal arithmetic

(ZAP,SP,MP,DP,UNPK,CVD,EDMK opcodes).

TEMPERAT CSECT

USING TEMPERAT,R15

EDMASKN DC X'402021204B202060' CL8 5num

YREGS

{{out}}

<pre>

 

=={{header|8th}}==

273.15 n:-

;

bye

;

{{out}}

<pre>>8th temp.8th 21

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

{{libheader|Action! Tool Kit}}

 

PROC K2C(REAL POINTER k,c)

ValR("373.15",k) Test("Water boils",k)

RETURN

{{out}}

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

=={{header|Ada}}==

 

 

procedure Temperatur_Conversion is

Put("F: "); Put(F, Fore => 4, Aft => 2, Exp => 0); New_Line;-- F: dddd.dd

Put("R: "); Put(R, Fore => 4, Aft => 2, Exp => 0); New_Line;-- R: dddd.dd

 

{{out}}

 

=={{header|Aime}}==

show(integer symbol, real temperature)

{

 

return 0;

{{out}}

<pre>aime$ aime -a tmp/tconvert 300

 

=={{header|ALGOL 68}}==

BEGIN

REAL kelvin;

printf ((f, kelvin, 9.0 * kelvin / 5.0, "R"));

printf ((f, kelvin, 9.0 * kelvin / 5.0 - 459.67, "F"))

{{out}}

<pre>$ echo 21 | a68g Temperature_conversion.a68

=={{header|ALGOL-M}}==

If the temperature in Kelvin is a whole number, you should type a decimal point after it (e.g. <code>290.</code>): <code>290</code> with no decimal point will be interpreted as 0.29 rather than 290.0.

DECIMAL K, C, F, R;

WRITE( "Temperature in Kelvin:" );

WRITE( F, " degrees Fahrenheit" );

WRITE( R, " degrees Rankine" );

 

=={{header|Amazing Hopper}}==

/* MISTRAL - a flavour of Hopper */

 

FUNCIÓN( Conversión Kelvin a Rankine, k)

RETORNAR ( {k} POR (1.8), REDONDEADO AL DECIMAL(2) )

<p>Another version:</p>

/* MISTRAL - a flavour of Hopper */

 

IMPRIMIR("RANKINE : ",temperatura, POR '1.8', NL)

FINALIZAR

<p>Another version:</p>

#include <mistral.h>

 

"RANKINE : ", {temperatura} POR '1.8', NL)

FINALIZAR

<p>Or another (and last) version:</p>

#include <mistral.h>

 

"RANKINE : ", rankine, NL)

FINALIZAR

{{out}}

<pre>

=={{header|APL}}==

Given a temperature in Kelvin, prints the equivalent in Kelvin, Celsius, Fahrenheit, and Rankine (in that order).

{{out}}

The "high minus" character <tt>¯</tt> is used in APL to mark negative numbers, preventing any possible confusion with <tt>-</tt> (the subtraction operator).

 

=={{header|AppleScript}}==

{{Trans|JavaScript}} ( ES6 version )

 

-- KELVIN TO OTHER SCALE -----------------------------------------------------

((ca's NSString's stringWithString:(str))'s ¬

lowercaseStringWithLocale:(ca's NSLocale's currentLocale())) as text

{{Out}}

<pre>K 21.0

Or of course:

 

return ("K" & tab & (kelvinValue as real)) & ¬

(linefeed & "C" & tab & (kelvinValue - 273.15)) & ¬

end convertFromKelvin

 

 

Vanilla AppleScript actually has a handful of built-in measurement unit coercions, including three for converting between temperatures in Kelvin, Celsius, and Fahrenheit. There isn't one for Rankine, but it's an easy calculation from Kelvin:

 

set kelvinMeasurement to kelvinValue as degrees Kelvin

end convertFromKelvin

 

 

As from macOS 10.12 Sierra, macOS's Foundation framework too offers "Units and Measurement" classes and methods, which can be accessed from AppleScript using ASObjC code. They offer many more categories and units, although it's usually easier, faster, and more efficient (and occasionally more accurate!) to look up the conversion formulae on Wikipedia and write the math directly into the scripts, as above.

 

use framework "Foundation"

 

end convertFromKelvin

 

 

=={{header|Arturo}}==

 

#[

celcius: k - 273.15

]

 

 

{{out}}

 

=={{header|AutoHotkey}}==

. "Celsius:`t`t" kelvinToCelsius(21) " C`n"

. "Fahrenheit:`t" kelvinToFahrenheit(21) " F`n"

{

return, round(k * 1.8, 2)

{{out}}

<pre>Kelvin: 21.00 K

 

=={{header|AutoIt}}==

 

Local Const $_KELVIN = 21

Return Round($degrees * 1.8, 2)

EndSelect

{{out}}

<pre>Kelvin: 21°

=={{header|AWK}}==

"Interactive" version, reading from stdin only:

BEGIN {

while (1) {

}

exit(0)

 

"Regular" version, reading from input-file(s). <br>

 

{{works with|gawk}} BEGINFILE is a gawk-extension

 

BEGIN { print("# Temperature conversion\n") }

 

END { print("# Bye.") }

 

{{out|Input}} the numeric value of the first word in each line is used as input for the conversion

=={{header|BASIC}}==

 

10 REM TRANSLATION OF AWK VERSION

20 INPUT "KELVIN DEGREES",K

100 PRINT R; " DEGREES RANKINE"

110 GOTO 20

 

==={{header|QBasic}}===

INPUT "Kelvin degrees (>=0): ", K

LOOP UNTIL K >= 0

PRINT "F = " + STR$(K * 1.8 - 459.67)

PRINT "R = " + STR$(K * 1.8)

 

==={{header|True BASIC}}===

{{works with|QBasic}}

PRINT "Kelvin degrees (>=0): ";

INPUT K

PRINT "F = "; STR$(K * 1.8 - 459.67)

PRINT "R = "; STR$(K * 1.8)

 

==={{header|Yabasic}}===

input "Kelvin degrees (>=0): " K

until K >= 0

print "F = " + str$(K * 1.8 - 459.67)

print "R = " + str$(K * 1.8)

 

==={{header|IS-BASIC}}===

110 PRINT K;TAB(10);"Kelvin is equivalent to"

120 PRINT K-273.15;TAB(10);"Degrees Celsius"

130 PRINT K*1.8-459.67;TAB(10);"Degrees Fahrenheit"

 

==={{header|Sinclair ZX81 BASIC}}===

20 INPUT K

30 PRINT K;" KELVINS ="

40 PRINT K-273.15;" DEGREES CELSIUS"

50 PRINT K*1.8-459.67;" DEGREES FAHRENHEIT"

 

==={{Header|Tiny BASIC}}===

PRINT "Temperature in Kelvin?"

INPUT K

PRINT C," Celsius"

PRINT F," Fahrenheit"

 

=={{header|BASIC256}}==

do

print "Kelvin degrees (>=0): ";

print "F = " + string(K * 1.8 - 459.67)

print "R = " + string(K * 1.8)

 

=={{header|BBC BASIC}}==

REPEAT

INPUT "Kelvin degrees (>=0): " K

PRINT "R = " K * 1.8

END

{{out}}

<pre>

The temperature to convert is read from stdin. Befunge has no support for real numbers, though, so reading and writing of decimal values is done with character I/O. For the same reason, the temperature calculations use integer arithmetic to emulate fixed point. The first two lines handle the input; the second line performs the conversion calculations; and the last three handle the output.

 

1#<<^0 /2++g001!<1 \+g00\+*+55\< ^+55\-1< ^*+55\+1<v_

"K"\-+**"!Y]"9:\"C"\--\**"^CIT"/5*9:\"F"\/5*9:\"R"\0\0<v

v/+55\+*86%+55: /+55\+*86%+55: \0/+55+5*-\1*2 p00:`\0:,<

>"."\>:55+% 68*v >:#,_$55+,\:!#@_^

 

{{out}}

 

=={{header|Bracmat}}==

= minus fixedpointnumber number decimals

. !arg:(#?number.~<0:~/#?decimals)

)

& done!

{{out}}

<pre>Enter Kelvin temperature:21.00

 

=={{header|C}}==

#include <stdlib.h>

 

}

return 0;

 

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

 

namespace TemperatureConversion

}

}

 

<pre>

 

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

#include <iostream>

#include <iomanip>

}

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

{{out}}

<pre>

 

=={{header|Ceylon}}==

 

void printKelvinConversions(Float kelvin) {

printKelvinConversions(21.0);

 

=={{header|Clojure}}==

{{trans|Common Lisp}}

(- k 273.15))

(defn to-fahrenheit [k]

(format "Celsius: %.2f Fahrenheit: %.2f Rankine: %.2f"

(to-celsius k) (to-fahrenheit k) (to-rankine k))

 

{{out}}

 

=={{header|CLU}}==

return(k)

end kelvin

stream$putl(po, f_form(c.func(k), 6, 2))

end

{{out}}

<pre>Enter temperature in Kelvin: 21

=={{header|COBOL}}==

{{works with|Visual COBOL}}

PROGRAM-ID. temp-conversion.

GOBACK

 

{{out}}

Three functions define the necessary conversion formulas. A fancy format string is used to print these values.

 

(defun to-celsius (k)

(- k 273.15))

(to-celsius k) (to-fahrenheit k) (to-rankine k))

(format t "Error: Non-numeric value entered."))))

 

{{out}}

 

=={{header|D}}==

return k - 273.15;

}

writefln("%2.2f K is below absolute zero", kelvin);

}

{{out}}

<pre>

 

=={{header|Delphi}}==

program Temperature;

 

readln;

end.

{{out}}

<pre>

=={{header|EasyLang}}==

 

print k & " °K"

print k - 273.15 & " °C"

print k * 1.8 - 459.67 & " °F"

 

=={{header|Elena}}==

ELENA 4.1 :

convertKelvinToFahrenheit(x)

console.printLine("Celsius: ", convertKelvinToCelsius(kelvinTemp));

console.readChar()

{{out}}

<pre>

 

=={{header|Elixir}}==

def conversion(t) do

IO.puts "K : #{f(t)}"

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module(temp_conv).

-export([main/0]).

f(A) ->

(round(A*100))/100 .

{{out}}

<pre>

 

=={{header|Euphoria}}==

include std/console.e

 

printf(1,"K = %5.2f\nC = %5.2f\nF = %5.2f\nR = %5.2f\n\n",{K,K-273.15,K*1.8-459.67,K*1.8})

end while

{{out}}

<pre>

 

=={{header|Excel}}==

B1 : Celsius

C1 : Fahrenheit

C2 : =K*1.8-459.67

D2 : =K*1.8

{{Out}}

<pre>

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(toUnit,

LAMBDA(n,

)

)

 

The example below generates the spaced list of test values on the left from the expression ENUMFROMTHENTO(240)(250)(390),

applying the following custom function:

=LAMBDA(a,

LAMBDA(b,

)

)

 

The four columns on the right of the output read their target format from the label cell at the top of each column.

 

=={{header|Ezhil}}==

# convert from Kelvin

நிரல்பாகம் கெல்வின்_இருந்து_மாற்று( k )

கெல்வின்_இருந்து_மாற்று( 273 ) #freezing pt of water

கெல்வின்_இருந்து_மாற்று( 30 + 273 ) #room temperature in Summer

 

=={{header|F_Sharp|F#}}==

// Define units of measure

[<Measure>] type k

printfn "%A Kelvin is %A Fahrenheit" K (kelvinToFahrenheit K)

printfn "%A Kelvin is %A Rankine" K (kelvinToRankine K)

 

=={{header|Factor}}==

IN: rosetta-code.temperature

 

"K %.2f\nC %.2f\nF %.2f\nR %.2f\n" printf ;

{{out}}

<pre>

 

=={{header|FOCAL}}==

01.20 TYPE "K ", %6.02, K, !

01.30 TYPE "C ", %6.02, K - 273.15, !

01.40 TYPE "F ", %6.02, K * 1.8 - 459.67, !

{{out}}

<pre>TEMPERATURE IN KELVIN:373.15

=={{header|Forth}}==

{{works with|GNU Forth}} for the command line handling

: k>°R ( F: kelvin -- rankine ) 1.8e0 f* ;

: °R>°F ( F: rankine -- fahrenheit ) 459.67e0 f- ;

then ;

 

{{out}}

<pre>&gt; gforthamd64 rosetta_temp_conv.fs 21

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

end subroutine

 

=={{header|FreeBASIC}}==

 

Sub convKelvin(temp As Double)

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Gambas}}==

Dim fKelvin As Float

 

Print "Rankine =\t" & Format(Str(fKelvin * 1.8), "#.00")

 

Output:

<pre>

 

=={{header|Go}}==

 

import (

fmt.Printf("F %.2f\n", k*9/5-459.67)

fmt.Printf("R %.2f\n", k*9/5)

{{out}}

<pre>

 

=={{header|Groovy}}==

class Convert{

static void main(String[] args){

static def k_to_r(def k=21.0){return k*1.8;}

}

{{out}}

<pre>

=={{header|Haskell}}==

 

import Control.Monad (mapM_)

 

where labels = ["kelvin: ", "celcius: ", "farenheit: ", "rankine: "]

conversions = [id, subtract 273, subtract 459.67 . (1.8 *), (*1.8)]

 

Or with properly managed exceptions:

 

 

import System.Exit (die)

t <- liftIO getLine >>= tryRead "Could not read temp"

tryAssert "Temp cannot be negative" (t>=0)

 

=={{header|Icon}} and {{header|Unicon}}==

 

The following program works in both languages:

k := A[1] | 21.00

write("K ",k)

write("R ",r := k*(9.0/5.0))

write("F ",r - 459.67)

 

Sample runs:

 

=={{header|J}}==

K2K =: 0 1 NB. K = (1 *k) + 0

K2C =: _273 1 NB. C = (1 *k) - 273

NB. numeric matrix J programs would manipulate

NB. directly.

{{out|Example}}

NB. temp with scale, for human legibility

fmt =: [: (;:inv"1) 0 _1 |: 'KCFR' ;"0 1"_1 '0.2' 8!:0 ]

C -252.00 -173.00 27.00

F -421.87 -279.67 80.33

'''Notes''': The approach is founded on polynomials, one for each conversion (e.g. <tt>Fahrenheit = 1.8*x - 459.67</tt> where <tt>x</tt> is measured in degrees Kelvin), and all polynomials are evaluated simultaneously using the built-in <code>p.</code>. Through some code decorations (specifically the <code>/</code> in <code>p./</code> the <code>"0 1"_1</code> and the <code>0 _1 |:</code>), we permit our function to convert arrays of temperatures of arbitrarily high dimension (a single temp, lists of temps, tables of temps, cubes of temps, etc).

 

=={{header|Java}}==

public static void main(String args[]) {

if (args.length == 1) {

return k * 1.8;

}

{{out}}

<pre>

 

===ES5===

var k2r = k => k * 1.8

var k2f = k => k2r(k) - 459.67

kCnv(21)

{{out}}

<pre>

Deriving '''kelvinTranslations()''' from a more general '''heatBabel()''' function.

 

'use strict';

 

 

})();

 

{{Out}}

 

=={{header|jq}}==

# round(keep) takes as input any jq (i.e. JSON) number and emits a string.

# "keep" is the desired maximum number of numerals after the decimal point,

end;

 

'''Example'''

21

Kelvin: 21

-1

 

=={{header|Julia}}==

"Celsius: $(round(k-273.15,2)), ",

"Fahrenheit: $(round(k*1.8-459.67,2)), ",

<pre>julia> cfr(21)

Kelvin: 21, Celsius: -252.15, Fahrenheit: -421.87, Rankine: 37.8</pre>

 

=={{header|Kotlin}}==

 

class Kelvin(val degrees: Double) {

println("F ${f.format(k.toFahreneit())}\n")

println("R ${f.format(k.toRankine())}")

 

{{out}}

 

=={{header|Lambdatalk}}==

{def to-celsius {lambda {:k} {- :k 273.15}}}

-> to-celsius

-421.87 farenheit

37.8 rankine

 

=={{header|Lasso}}==

 

local(

tempconverter(37.80, 'r')

'<br />'

<pre>K = 21.00 C = -252.15 R = 37.80 F = -421.87

K = 294.15 C = 21.00 R = 529.47 F = 69.80

 

=={{header|LIL}}==

func kToc k {expr $k - 273.15}

func kTor k {expr $k / 5.0 * 9.0}

print "Fahrenheit: [kTof $k]"

print "Rankine: [kTor $k]"

 

{{out}}

 

=={{header|LiveCode}}==

put k/5 * 9 into r

put k - 273.15 into c

put r - 459.67 into f

return k,r,c,f

put item 1 of tTemp into temperature["Kelvin"]

put item 2 of tTemp into temperature["Rankine"]

put temperature

 

 

=={{header|Lua}}==

 

local c = k - 273.15

local r = k * 1.8

Rankine: %.2f °R

Fahrenheit: %.2f °F

 

=={{header|Liberty BASIC}}==

 

Input "Kelvin degrees (>=0): ";K

Loop Until (K >= 0)

Print "F = ";(K * 1.8 - 459.67)

Print "R = ";(K * 1.8)

 

{{out}}

 

=={{header|Maple}}==

seq(printf("%c: %.2f\n", StringTools[UpperCase](substring(i, 1)), convert(k, temperature, kelvin, i)), i in [kelvin, Celsius, Fahrenheit, Rankine]);

return NULL;

end proc:

 

{{out}}

<pre>

 

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

{{out}}

<pre>21.K -> {-421.87°F,-252.15°C,37.8°R}</pre>

=={{header|min}}==

{{works with|min|0.19.3}}

((float) (273.15 -) (9 5 / * 459.67 -) (9 5 / *)) cleave

() 'cons 4 times "K $1\nC $2\nF $3\nR $4" swap % puts!

) :convert

 

{{out}}

<pre>

 

=={{header|MiniScript}}==

print temp + " degrees in Kelvin is:"

Celsius = temp - 273.15

 

temp = input("Enter a temperature in Kelvin: ")

{{out}}

<pre>

 

=={{header|MiniZinc}}==

 

var float: celsius;

solve satisfy;

 

{{out}}<pre>

Compiling temperature.mzn, additional arguments kelvin=1000;

 

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

/ 3 2 + П9 ИП7 2 7 3 ,

1 5 + П4 С/П П8 1 , 8 /

БП 00 П9 3 2 - 5 * 9 /

БП 00 П4 2 7 3 , 1 5 -

 

''Instruction:''

==={{header|mLite}}===

Temperature in Kelvin given on command line.

fun KtoF n = n * 1.8 - 459.67;

fun KtoR n = n * 1.8;

print "Rankine: "; println ` KtoR K

end

 

=={{header|Nanoquery}}==

{{trans|Python}}

... print "K ? "

... k = float(input())

K ? 222.2

222.200 Kelvin = -50.9500 Celsius = -59.7100 Fahrenheit = 399.960 Rankine degrees.

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols

 

 

return

{{out}}

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

 

=={{header|Never}}==

func KtoC(k : float) -> float { k - 273.15 }

func KtoF(k : float) -> float { k * 1.8 - 459.67 }

0

}

{{output}}

<pre>

 

=={{header|NewLISP}}==

(define (to-celsius k)

(- k 273.15)

)

)

{{out}}

<pre>

=={{header|Nim}}==

{{libheader|strfmt}}

 

while true:

let k = parseFloat readLineFromStdin "K ? "

echo "{:g} Kelvin = {:g} Celsius = {:g} Fahrenheit = {:g} Rankine degrees".fmt(

Sample usage:

<pre>K ? 21.0

 

=={{header|Objeck}}==

class Temperature {

function : Main(args : String[]) ~ Nil {

}

}

 

<pre>

 

=={{header|Objective-C}}==

 

int main(int argc, const char * argv[])

}

return 0;

 

=={{header|OCaml}}==

let print_temp s t =

print_string s;

print_temp "F " (kelvin_to_fahrenheit k);

print_temp "R " (kelvin_to_rankine k);;

 

Sample session:

=={{header|Oforth}}==

 

: kelvinToFahrenheit 1.8 * 459.67 - ;

: kelvinToRankine 1.8 * ;

n kelvinToCelsius println

n kelvinToFahrenheit println

 

{{out}}

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}}==

 

type

writeln(' ', ConvertTemperature(kelvin, K, F) : 3 : 2, ' in degrees Fahrenheit.');

writeln(' ', ConvertTemperature(kelvin, K, R) : 3 : 2, ' in degrees Rankine.');

 

{{out}}

 

=={{header|Perl}}==

Celcius => { factor => 1 , offset => -273.15 },

Rankine => { factor => 1.8, offset => 0 },

foreach (sort keys %scale) {

printf "%12s:%8.2f\n", $_, $kelvin * $scale{$_}{factor} + $scale{$_}{offset};

{{out}}

<pre>

=={{header|Phix}}==

Modified copy of [[Temperature_conversion#Euphoria|Euphoria]]

<span style="color: #004080;">atom</span> <span style="color: #000000;">K</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prompt_number</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Enter temperature in Kelvin >=0: "</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1e307</span><span style="color: #0000FF;">})</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" Kelvin: %5.2f\n Celsius: %5.2f\nFahrenheit: %5.2f\n Rankine: %5.2f\n\n"</span><span style="color: #0000FF;">,</span>

<span style="color: #0000FF;">{</span><span style="color: #000000;">K</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">K</span><span style="color: #0000FF;">-</span><span style="color: #000000;">273.15</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">K</span><span style="color: #0000FF;">*</span><span style="color: #000000;">1.8</span><span style="color: #0000FF;">-</span><span style="color: #000000;">459.67</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">K</span><span style="color: #0000FF;">*</span><span style="color: #000000;">1.8</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

 

=={{header|PHP}}==

 

while (true) {

}

}

{{out}}

<pre>Enter a value in kelvin (q to quit): 21

 

=={{header|PicoLisp}}==

 

(de convertKelvin (Kelvin)

(tab (-3 8)

(car X)

Test:

{{out}}

<pre>K 21.00

 

=={{header|PL/I}}==

/* PL/I **************************************************************

* 15.08.2013 Walter Pachl translated from NetRexx

End;

End;

{{out}}

<pre>

 

=={{header|Plain English}}==

Start up.

Put 21 into a kelvin temperature.

Show the celsius temperature given "C".

Show the fahrenheit temperature given "F".

{{out}}

<pre>

=={{header|PowerShell}}==

{{trans|Tcl}}

try{

$c = $k - 273.15

 

$input=Read-host "Enter a temperature in Kelvin"

{{Out}}

<pre>PS> ./TEMPS

===PowerShell Alternate Version===

A more "PowerShelly" way to do it.

function Convert-Kelvin

{

}

}

21, 100 | Convert-Kelvin

{{Out}}

<pre>

 

=={{header|PureBasic}}==

Procedure.d Kelvin2Fahrenheit(tK.d) : ProcedureReturn tK*1.8-459.67 : EndProcedure

Procedure.d Kelvin2Rankine(tK.d) : ProcedureReturn tK*1.8 : EndProcedure

k$=Inkey() : Delay(50) : If RawKey()=#ESC : End : EndIf

Until RawKey()

<pre>Temperatur Kelvin? 21

Conversion:

 

=={{header|Python}}==

k = float(input('K ? '))

print("%g Kelvin = %g Celsius = %g Fahrenheit = %g Rankine degrees."

K ? 222.2

222.2 Kelvin = -50.95 Celsius = -59.71 Fahrenheit = 399.96 Rankine degrees.

 

===Python: Universal conversion===

This converts from any one of the units to all the others

'F': (lambda f: (f + 459.67) / 1.8),

'R': (lambda r: r / 1.8),

<value> <K/R/F/C> ? 399.96 R

222.2 Kelvin = -50.95 Celsius = -59.71 Fahrenheit = 399.96 Rankine degrees.

 

=={{header|QB64}}==

Dim As Single Celsius, Kelvin, Fahrenheit, Rankine

 

Kelvin = -300

Wend

 

=={{header|Quackery}}==

Using the Quackery big number rational arithmetic library <code>bigrat.qky</code>.

 

[ 5 9 v* ] is r->k ( n/d --> n/d )

say " degrees Rankine" cr ] is task ( $ --> )

 

{{out}}

 

=={{header|R}}==

if (!is.numeric(K))

stop("\n Input has to be numeric")

convert_Kelvin(21)

 

{{out}}

Although not exactly the shortest code,

the converter function can turn any temperature into any other

(define (converter temp init final)

(define to-k

;Fahrenheit: -421.87

;Rankine: 37.800000000000004

 

=={{header|Raku}}==

 

{{trans|Perl}}

Celcius => { factor => 1 , offset => -273.15 },

Rankine => { factor => 1.8, offset => 0 },

for %scale.sort {

printf "%12s: %7.2f\n", .key, $kelvin * .value<factor> + .value<offset>;

 

{{out}}

Alternative version that accepts the input in any of the four scales:

 

my $k = do given $answer {

when s/:i C $// { $_ + 273.15 }

say " { $k * 1.8 - 459.67 }℉";

say " { $k * 1.8 }R";

{{out}}

<pre>Temperature: 0

::* comments (annotation notes) allowed within the list

::* aligned output (whole numbers and decimal fractions)

numeric digits 120 /*be able to support some huge numbers.*/

parse arg tList /*get the specified temperature list. */

otherwise call serr 'illegal temperature scale:' y

end /*select*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 98.6F to C, &nbsp; -40C, 0 c (water freezes), &nbsp; 37C (body temp), &nbsp; 100 C (water boils), &nbsp; 21 degrees Kelvin, &nbsp; 0 K (outer space?) </tt>}}

<pre>

 

=={{header|Ring}}==

k = 21.0 c = 0 r = 0 f = 0

convertTemp(k)

r = k * 1.8

f = r - 459.67

 

=={{header|Ruby}}==

 

FROM_TEMP_SCALE_TO_K =

end

Converts all eight scales to any other scale, by means of method_missing.

 

Usage:

TempConvert.kelvin_to_fahrenheit 100 #=> -279.67

TempConvert.kelvin_to_rankine 100 #=> 180.0

TempConvert.newton_to_celsius 100 #=> 303.03

TempConvert.newton_to_fahrenheit 100 #=> 577.45

 

=={{header|Run BASIC}}==

input "Kelvin Degrees";kelvin

if kelvin <= 0 then end ' zero or less ends the program

rankine = kelvin * 1.8

print kelvin;" kelvin is equal to ";celcius; " degrees celcius and ";fahrenheit;" degrees fahrenheit and ";rankine; " degrees rankine"

 

=={{header|Scala}}==

{{libheader|Scala}}

 

def kelvinToCelsius(k: Double) = k + 273.15

}

} else println("Temperature not given.")

{{out}}

<pre>

 

=={{header|Rust}}==

print!("Enter temperature in Kelvin to convert: ");

let mut input = String::new();

 

Ok(())

 

=={{header|Scheme}}==

 

(import (scheme base)

(scheme read)

(display "Fahrenheit: ") (display (kelvin->fahrenheit k)) (newline)

(display "Rankine : ") (display (kelvin->rankine k)) (newline)))

 

{{out}}

 

=={{header|Seed7}}==

include "float.s7i";

 

writeln("F: " <& fahrenheit(kelvin) digits 2 lpad 7);

writeln("R: " <& rankine(kelvin) digits 2 lpad 7);

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

Celcius => Hash.new(factor => 1 , offset => -273.15 ),

Rankine => Hash.new(factor => 1.8, offset => 0 ),

scale.keys.sort.each { |key|

printf("%12s:%8.2f\n", key, kelvin*scale{key}{:factor} + scale{key}{:offset});

{{out}}

<pre>

=={{header|Swift}}==

 

func KtoC(kelvin : Double)->Double{

var r=KtoR(kelvin : k)

print("\(r) Rankine")

 

=={{header|Tcl}}==

set c [expr {$k - 273.15}]

set r [expr {$k / 5.0 * 9.0}]

set f [expr {$r - 459.67}]

list $k $c $f $r

 

 

Demonstrating:

flush stdout

lassign [temps [gets stdin]] k c f r

puts [format "C: %.2f" $c]

puts [format "F: %.2f" $f]

{{out}}

<pre>

==={{header|Korn Shell}}===

{{works with|ksh}}

# Temperature conversion

typeset tt[1]=0.00 tt[2]=273.15 tt[3]=373.15

echo "Fahrenheit: $((t*18/10-459.67)) F"

echo "Rankine: $((t*18/10)) R"

 

==={{header|bash}}===

{{works with|Bourne Again SHell}}

# Temperature conversion

tt[1]=0.00; tt[2]=273.15; tt[3]=373.15

echo "Fahrenheit: $(bc<<<"scale=2;$t*18/10-459.67") F"

echo "Rankine: $(bc<<<"scale=2;$t*18/10") R"

 

=={{header|Ursa}}==

while true

out "Temp. in Kelvin? " console

out "K\t" k endl "C\t" (- k 273.15) endl console

out "F\t" (- (* k 1.8) 459.67) endl "R\t" (* k 1.8) endl endl console

 

=={{header|VBA}}==

 

Option Explicit

 

End Select

End Function

{{out}}

<pre>Input in Kelvin : 21,00

 

=={{header|VBScript}}==

WScript.StdOut.Write "Enter the temperature in Kelvin:"

tmp = WScript.StdIn.ReadLine

rankine = (k-273.15)*1.8+491.67

End Function

 

{{Out}}

 

=={{header|Visual FoxPro}}==

#DEFINE ABSZF 459.67

LOCAL k As Double, c As Double, f As Double, r As Double, n As Integer, ;

ENDDO

SET FIXED &cf

{{out}}

<pre>

=={{header|Vlang}}==

Note: round_sig in 0.3 or later

 

fn main() {

rankine := math.round_sig(kelvin * 1.8, 2)

return celsius.str(), fahrenheit.str(), rankine.str()

 

{{out}}

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var tempConv = Fn.new { |k|

 

var ks = [0, 21, 100]

 

{{out}}

 

=={{header|XLISP}}==

(SETQ *FLONUM-FORMAT* "%.2f")

(DISPLAY "Enter a temperature in Kelvin.")

(DISPLAY `(F = ,(- (* K 1.8) 459.67)))

(NEWLINE)

{{out}}

<pre>(CONVERT-TEMPERATURE)

 

=={{header|XPL0}}==

real K, C, F, R;

[ChOut(0, ^K); K:= RlIn(0);

R:= F + 459.67;

ChOut(0, ^R); RlOut(0, R); CrLf(0);

{{out}}

<pre>

 

=={{header|zkl}}==

println("K %.2f".fmt(K));

println("F %.2f".fmt(K*1.8 - 459.67));

println("C %.2f".fmt(K - 273.15));

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

 

20 INPUT "Kelvin Degrees? ";k

30 IF k <= 0 THEN STOP: REM A value of zero or less will end program

90 PRINT f; " Degrees Fahrenheit"

100 PRINT r; " Degrees Rankine"