Temperature conversion: Difference between revisions

From Rosetta Code
Content added Content deleted
(8th)
Line 59: Line 59:
argc 0 n:=
argc 0 n:=
if
if
"Syntax" . cr " temp.8th" . cr
"Syntax" . cr " temp.8th number" . cr
else
else
0 args >n KtoCFR
0 args >n KtoCFR

Revision as of 00:56, 11 March 2015

Task
Temperature conversion
You are encouraged to solve this task according to the task description, using any language you may know.

There are quite a number of temperature scales.
For this task we will concentrate on 4 of the perhaps best-known ones: Kelvin, Celsius, Fahrenheit and Rankine.

The Celsius and Kelvin scales have the same magnitude, but different null points.

0 degrees Celsius corresponds to 273.15 kelvin.
0 kelvin is absolute zero.

The Fahrenheit and Rankine scales also have the same magnitude, but different null points.

0 degrees Fahrenheit corresponds to 459.67 degrees Rankine.
0 degrees Rankine is absolute zero.

The Celsius/Kelvin and Fahrenheit/Rankine scales have a ratio of 5 : 9.

Write code that accepts a value of kelvin, converts it to values on the three other scales and prints the result.

For instance: 

K  21.00

C  -252.15

F  -421.87

R  37.80

8th

<lang forth>: KtoC \ n -- n 273.15 n:-

KtoF \ n -- n

1.8 n:* 459.67 n:-

KtoR \ n -- n

1.8 n:*

KtoCFR \ n --

dup dup dup . " degrees Kelvin" . cr KtoC . " degrees Celcius" . cr KtoF . " degrees Fahrenheit" . cr KtoR . " degrees Rankine" . cr

app:main \

argc 0 n:= if "Syntax" . cr " temp.8th number" . cr else 0 args >n KtoCFR then bye

</lang>

Output:
>8th temp.8th 21
21 degrees Kelvin
-252.15000 degrees Celcius
-421.87000 degrees Fahrenheit
37.80000 degrees Rankine

Ada

<lang Ada>with Ada.Float_Text_IO, Ada.Text_IO; use Ada.Float_Text_IO, Ada.Text_IO;

procedure Temperatur_Conversion is 

  K: Float;
  function C return Float is (K - 273.15);
  function F return Float is (K * 1.8 - 459.67);
  function R return Float is (K * 1.8);

begin 

  Get(K); New_Line;                                           -- Format 
  Put("K: "); Put(K, Fore => 4, Aft => 2, Exp => 0); New_Line;-- K: dddd.dd
  Put("C: "); Put(C, Fore => 4, Aft => 2, Exp => 0); New_Line;-- C: dddd.dd
  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

end;</lang>

Output:
21.0

K:   21.00
C: -252.15
F: -421.87
R:   37.80

Aime

<lang aime>void show(integer symbol, real temperature) { 

   o_form("%c /d2p2w8/\n", symbol, temperature);

}

integer main(void) { 

   real k;

   k = atof(argv(1));

   show('K', k);
   show('C', k - 273.15);
   show('F', k * 1.8 - 459.67);
   show('R', k * 1.8);

   return 0;

}</lang>

Output:
aime$ aime -a tmp/tconvert 300
K   300   
C    26.85
F    80.32
R   540

AutoHotkey

<lang AutoHotkey>MsgBox, % "Kelvin:`t`t 21.00 K`n" 

       . "Celsius:`t`t" kelvinToCelsius(21) " C`n"
       . "Fahrenheit:`t" kelvinToFahrenheit(21) " F`n"
       . "Rankine:`t`t" kelvinToRankine(21) " R`n"

kelvinToCelsius(k) { 

   return, round(k - 273.15, 2)

} kelvinToFahrenheit(k) { 

   return, round(k * 1.8 - 459.67, 2)

} kelvinToRankine(k) { 

   return, round(k * 1.8, 2)

}</lang>

Output:
Kelvin:          21.00 K
Celsius:       -252.15 C
Fahrenheit:    -421.87 F
Rankine:         37.80 R

AWK

"Interactive" version, reading from stdin only: <lang AWK># syntax: AWK -f TEMPERATURE_CONVERSION.AWK BEGIN { 

   while (1) {
     printf("\nKelvin degrees? ")
     getline K
     if (K ~ /^$/) {
       break
     }
     if (K < 0) {
       print("K must be > 0")
       continue
     }
     printf("K = %.2f\n",K)
     printf("C = %.2f\n",K - 273.15)
     printf("F = %.2f\n",K * 1.8 - 459.67)
     printf("R = %.2f\n",K * 1.8)
   }
   exit(0)

}</lang>

"Regular" version, reading from input-file(s).
With no such file, or "-" as filename, reading from stdin:

Works with: gawk

BEGINFILE is a gawk-extension

<lang AWK># usage: gawk -f temperature_conversion.awk input.txt -

BEGIN { print("# Temperature conversion\n") } BEGINFILE { print "# reading", FILENAME 

           if( FILENAME=="-" ) print "# Please enter temperature values in K:\n"
         }

!NF { exit } 

         { print "Input:" $0 }

$1<0 { print("K must be >= 0\n"); next } 

         { K = 0+$1
           printf("K = %8.2f Kelvin degrees\n",K)
           printf("C = %8.2f\n",  K - 273.15)
           printf("F = %8.2f\n",  K * 1.8 - 459.67)
           printf("R = %8.2f\n\n",K * 1.8)
         }

END { print("# Bye.") } </lang>

Input:

the numeric value of the first word in each line is used as input for the conversion 

-1
absolute
184
273.15 ice melts
310x
373.15 water boils
1941 Titanium melts

So, "absolute" has a value of 0, and 310x is just 310.

After that file is read and processed, values are read from stdin.
Here entering "333" by hand, and then stopping with an empty input.

Output:
# Temperature conversion

# reading input.txt
Input:-1
K must be >= 0

Input:absolute
K =     0.00 Kelvin degrees
C =  -273.15
F =  -459.67
R =     0.00

Input:184
K =   184.00 Kelvin degrees
C =   -89.15
F =  -128.47
R =   331.20

Input:273.15 ice melts
K =   273.15 Kelvin degrees
C =     0.00
F =    32.00
R =   491.67

Input:310x
K =   310.00 Kelvin degrees
C =    36.85
F =    98.33
R =   558.00

Input:373.15 water boils
K =   373.15 Kelvin degrees
C =   100.00
F =   212.00
R =   671.67

Input:1941 Titanium melts
K =  1941.00 Kelvin degrees
C =  1667.85
F =  3034.13
R =  3493.80

# reading -
# Please enter temperature values in K:

Input:333
K =   333.00 Kelvin degrees
C =    59.85
F =   139.73
R =   599.40

# Bye.

BASIC

<lang basic> 10 REM TRANSLATION OF AWK VERSION 20 INPUT "KELVIN DEGREES",K 30 IF K <= 0 THEN END: REM A VALUE OF ZERO OR LESS WILL END PROGRAM 40 LET C = K - 273.15 50 LET F = K * 1.8 - 459.67 60 LET R = K * 1.8 70 PRINT K; " KELVIN IS EQUIVALENT TO" 80 PRINT C; " DEGREES CELSIUS" 90 PRINT F; " DEGREES FAHRENHEIT" 100 PRINT R; " DEGREES RANKINE" 110 GOTO 20 </lang>

BASIC256

<lang basic256> do 

 print "Kelvin degrees (>=0): ";
 input K
 until K>=0

print "K = " + string(K) print "C = " + string(K - 273.15) print "F = " + string(K * 1.8 - 459.67) print "R = " + string(K * 1.8) </lang>

BBC BASIC

<lang bbcbasic> REPEAT 

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

UNTIL K>=0 @%=&20208 PRINT '"K = " K PRINT "C = " K - 273.15 PRINT "F = " K * 1.8 - 459.67 PRINT "R = " K * 1.8 END </lang>

Output:
Kelvin degrees (>=0): 21

K =    21.00
C =  -252.15
F =  -421.87
R =    37.80

Bracmat

<lang bracmat>( ( rational2fixedpoint 

 =   minus fixedpointnumber number decimals
   .   !arg:(#?number.~<0:~/#?decimals)
     & ( !number:0&"0.0"
       |     ( !number:>0&
             | -1*!number:?number&"-"
             )
           : ?minus
         & !number+1/2*10^(-1*!decimals):?number
         & !minus div$(!number.1) ".":?fixedpointnumber
         &   whl
           ' ( !decimals+-1:~<0:?decimals
             &     !fixedpointnumber
                   div$(mod$(!number.1)*10:?number.1)
               : ?fixedpointnumber
             )
         & str$!fixedpointnumber
       )
 )

& ( fixedpoint2rational 

 =   integerpart fractionalpart decimals
   .   @( !arg
        :   #?integerpart
            ( "." ?fractionalpart
            | &0:?fractionalpart
            )
        )
     & @(!fractionalpart:? #?fractionalpart [?decimals)
     &   !integerpart
       +   (!integerpart:<0&-1|1)
         * 10^(-1*!decimals)
         * !fractionalpart
 )

& whl 

 ' ( put$"Enter Kelvin temperature:"
   & fixedpoint2rational$(get'(,STR)):?kelvin
   & !kelvin+-27315/100:?celcius
   & (degree=.str$(chu$(x2d$b0) !arg))
   & out$(rational2fixedpoint$(!kelvin.2) K)
   & out$(rational2fixedpoint$(!celcius.2) degree$C)
   & out$(rational2fixedpoint$(!celcius*9/5+32.2) degree$F)
   & out$(rational2fixedpoint$(!kelvin*9/5.2) degree$Ra)
   & out$(rational2fixedpoint$(!celcius*4/5.2) degree$Ré)
   )

& done! )</lang>

Output:
Enter Kelvin temperature:21.00
21.00 K
-252.15 °C
-421.87 °F
37.80 °Ra
-201.72 °Ré

C

<lang c>#include <stdio.h>

  1. include <stdlib.h>

double kelvinToCelsius(double k){ 

   return k - 273.15;

}

double kelvinToFahrenheit(double k){ 

   return k * 1.8 - 459.67;

}

double kelvinToRankine(double k){ 

   return k * 1.8;

} void convertKelvin(double kelvin) { 

   printf("K %.2f\n", kelvin);
   printf("C %.2f\n", kelvinToCelsius(kelvin));
   printf("F %.2f\n", kelvinToFahrenheit(kelvin));
   printf("R %.2f", kelvinToRankine(kelvin));

}

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

   if (argc > 1) {
       double kelvin = atof(argv[1]);
       convertKelvin(kelvin);
   }
   return 0;

}</lang>

C++

<lang cpp>

  1. include <iostream>
  2. include <iomanip>

//-------------------------------------------------------------------------------------------------- using namespace std;

//-------------------------------------------------------------------------------------------------- class converter { public: 

   converter() : KTC( 273.15f ), KTDel( 3.0f / 2.0f ), KTF( 9.0f / 5.0f ), KTNew( 33.0f / 100.0f ),

KTRank( 9.0f / 5.0f ), KTRe( 4.0f / 5.0f ), KTRom( 21.0f / 40.0f ) {} 

   void convert( float kelvin )
   {

float cel = kelvin - KTC, del = ( 373.15f - kelvin ) * KTDel, fah = kelvin * KTF - 459.67f, net = cel * KTNew, rnk = kelvin * KTRank, rea = cel * KTRe, rom = cel * KTRom + 7.5f;

cout << endl << left << "TEMPERATURES:" << endl << "===============" << endl << setw( 13 ) << "CELSIUS:" << cel << endl << setw( 13 ) << "DELISLE:" << del << endl << setw( 13 ) << "FAHRENHEIT:" << fah << endl << setw( 13 ) << "KELVIN:" << kelvin << endl << setw( 13 ) << "NEWTON:" << net << endl << setw( 13 ) << "RANKINE:" << rnk << endl << setw( 13 ) << "REAUMUR:" << rea << endl << setw( 13 ) << "ROMER:" << rom << endl << endl << endl; } private: 

   const float KTRank, KTC, KTF, KTRe, KTDel, KTNew, KTRom;

}; //-------------------------------------------------------------------------------------------------- int main( int argc, char* argv[] ) { 

   converter con;
   float k;
   while( true )
   {

cout << "Enter the temperature in Kelvin to convert: "; cin >> k; con.convert( k ); system( "pause" ); system( "cls" ); 

   }
   return 0;

} //-------------------------------------------------------------------------------------------------- </lang>

Output:
Enter the temperature in Kelvin to convert: 373.15

TEMPERATURES:
===============
CELSIUS:     100
DELISLE:     0
FAHRENHEIT:  212
KELVIN:      373.15
NEWTON:      33
RANKINE:     671.67
REAUMUR:     80
ROMER:       60

C#

<lang csharp>using System;

namespace TemperatureConversion { 

   class Program
   {
       static Func<double, double> ConvertKelvinToFahrenheit = x => (x * 1.8) - 459.67;
       static Func<double, double> ConvertKelvinToRankine = x => x * 1.8;
       static Func<double, double> ConvertKelvinToCelsius = x => x = 273.13;

       static void Main(string[] args)
       {
           Console.Write("Enter a Kelvin Temperature: ");
           string inputVal = Console.ReadLine();
           double kelvinTemp = 0f;

           if (double.TryParse(inputVal, out kelvinTemp))
           {
               Console.WriteLine(string.Format("Kelvin: {0}", kelvinTemp));
               Console.WriteLine(string.Format("Fahrenheit: {0}", ConvertKelvinToFahrenheit(kelvinTemp)));
               Console.WriteLine(string.Format("Rankine: {0}", ConvertKelvinToRankine(kelvinTemp)));
               Console.WriteLine(string.Format("Celsius: {0}", ConvertKelvinToCelsius(kelvinTemp)));
               Console.ReadKey();
           }
           else
           {
               Console.WriteLine("Invalid input value: " + inputVal);
           }
       }
   }

}</lang> 

Enter a Kelvin Temperature: 21
Kelvin: 21
Fahrenheit: -421.87
Rankine: 37.8
Celsius: 273.13

Clojure

Translation of: Common Lisp

<lang clojure>(defn to-celsius [k] 

 (- k 273.15))

(defn to-fahrenheit [k] 

 (- (* k 1.8) 459.67))

(defn to-rankine [k] 

 (* k 1.8))

(defn temperature-conversion [k] 

 (if (number? k) 
   (format "Celsius: %.2f Fahrenheit: %.2f Rankine: %.2f" 
     (to-celsius k) (to-fahrenheit k) (to-rankine k)) 
   (format "Error: Non-numeric value entered.")))</lang>
Output:
user=> (temperature-conversion 21.0)
"Celsius: -252.15 Fahrenheit: -421.87 Rankine: 37.80"

COBOL

Works with: Visual COBOL

<lang cobol> IDENTIFICATION DIVISION. 

      PROGRAM-ID. temp-conversion.
      
      DATA DIVISION.
      WORKING-STORAGE SECTION.
      78  Kelvin-Rankine-Ratio    VALUE 0.5556. *> 5 / 9 to 4 d.p.
      78  Kelvin-Celsius-Diff     VALUE 273.15.
      78  Rankine-Fahrenheit-Diff VALUE 459.67.
      
      01  temp-kelvin             PIC S9(8)V99.
      01  temp-rankine            PIC S9(8)V99.
      
      01  kelvin                  PIC -(7)9.99.
      01  celsius                 PIC -(7)9.99.
      01  rankine                 PIC -(7)9.99.
      01  fahrenheit              PIC -(7)9.99.
      
      PROCEDURE DIVISION.
          DISPLAY "Enter a temperature in Kelvin to convert: " NO ADVANCING
          ACCEPT temp-kelvin
      
          MOVE temp-kelvin TO kelvin
          DISPLAY "K " kelvin
          
          SUBTRACT Kelvin-Celsius-Diff FROM temp-kelvin GIVING celsius
          DISPLAY "C " celsius
          
          DIVIDE temp-kelvin BY Kelvin-Rankine-Ratio
              GIVING temp-rankine, rankine
          SUBTRACT Rankine-Fahrenheit-Diff FROM temp-rankine GIVING fahrenheit
          
          DISPLAY "F " fahrenheit
          DISPLAY "R " rankine
      
          GOBACK
          .</lang>
Output:
Enter a temperature in Kelvin to convert: 21
K       21.00
C     -252.15
F     -421.88
R       37.79

Common Lisp

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

<lang lisp> (defun to-celsius (k) 

 (- k 273.15))

(defun to-fahrenheit (k) 

 (- (* k 1.8) 459.67))

(defun to-rankine (k) 

 (* k 1.8))

(defun temperature-conversion () 

 (let ((k (read))) 
   (if (numberp k) 
     (format t "Celsius: ~d~%Fahrenheit: ~d~%Rankine: ~d~%" 
       (to-celsius k) (to-fahrenheit k) (to-rankine k)) 
     (format t "Error: Non-numeric value entered."))))

</lang>

Output:
* (temperature-conversion)
21
Celsius: -252.15
Fahrenheit: -421.87003
Rankine: 37.8
NIL

D

<lang d>double kelvinToCelsius(in double k) pure nothrow @safe { 

   return k - 273.15;

}

double kelvinToFahrenheit(in double k) pure nothrow @safe { 

   return k * 1.8 - 459.67;

}

double kelvinToRankine(in double k) pure nothrow @safe { 

   return k * 1.8;

}

unittest { 

   import std.math: approxEqual;
   assert(approxEqual(kelvinToCelsius(21.0), -252.15));
   assert(approxEqual(kelvinToFahrenheit(21.0), -421.87));
   assert(approxEqual(kelvinToRankine(21.0), 37.8));

}

void main(string[] args) { 

   import std.stdio, std.conv, std.string;

   if (args.length == 2 && isNumeric(args[1])) {
       immutable kelvin = to!double(args[1]);
       if (kelvin >= 0) {
           writefln("K  %2.2f", kelvin);
           writefln("C  %2.2f", kelvinToCelsius(kelvin));
           writefln("F  %2.2f", kelvinToFahrenheit(kelvin));
           writefln("R  %2.2f", kelvinToRankine(kelvin));
       } else
           writefln("%2.2f K is below absolute zero", kelvin);
   }

}</lang>

Output:
K  21.00

C  -252.15

F  -421.87

R  37.80

Delphi

<lang delphi> program Temperature;

{$APPTYPE CONSOLE}

uses 

 SysUtils;

type 

 TTemp = class
 private
   fCelsius, fFahrenheit, fRankine: double;
 public
   constructor Create(aKelvin: double);
   property AsCelsius: double read fCelsius;
   property AsFahrenheit: double read fFahrenheit;
   property AsRankine: double read fRankine;
 end;

 { TTemp }

constructor TTemp.Create(aKelvin: double); begin 

 fCelsius := aKelvin - 273.15;
 fRankine := aKelvin * 9 / 5;
 fFahrenheit := fRankine - 459.67;

end;

var 

 kelvin: double;
 temp: TTemp;

begin 

 write('Kelvin: ');
 readln(kelvin);
 temp := TTemp.Create(kelvin);
 writeln(Format('Celsius: %.2f', [temp.AsCelsius]));
 writeln(Format('Fahrenheit: %.2f', [temp.AsFahrenheit]));
 writeln(Format('Rankine: %.2f', [temp.AsRankine]));
 temp.Free;
 readln;

end. </lang>

Output:
Kelvin: 21.00
Celsius: -252.15
F: -421.87
R: 37.80

Erlang

<lang erlang>% Implemented by Arjun Sunel -module(temp_conv). -export([main/0]).

main() -> conversion(21).

conversion(T) -> io:format("\nK : ~p\n\n",[f(T)]), io:format("C : ~p \n\n",[f(T - 273.15)]), io:format("F : ~p\n\n",[f(T * 1.8 - 459.67)]), io:format("R : ~p\n\n",[f(T * 1.8)]).

f(A) -> (round(A*100))/100 . </lang>

Output:
K : 21.0

C : -252.15 

F : -421.87

R : 37.8

ok

Euphoria

<lang OpenEuphoria> include std/console.e

atom K while 1 do K = prompt_number("Enter temperature in Kelvin >=0: ",{0,4294967296}) 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 </lang>

Output:
Enter temperature in Kelvin >=0: 21
K = 21.00
C = -252.15
F = -421.87
R = 37.80

Enter temperature in Kelvin >=0:

Excel

<lang>A1 : Kelvin B1 : Celsius C1 : Fahrenheit D1 : Rankine Name A2 : K B2 : =K-273.15 C2 : =K*1.8-459.67 D2 : =K*1.8 Input in A1 </lang>

Output:
  A          B          C          D
1 Kelvin     Celsius    Fahrenheit Rankine
2         21    -252.15    -421.87       37.8

Ezhil

<lang Ezhil>

  1. convert from Kelvin

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

பதிப்பி "Kelvin: ",k,"Celsius: ",round(k-273.15)," Fahrenheit: ",(round(k*1.8 - 459.67))," Rankine: ",(round(k*1.8))

முடி

கெல்வின்_இருந்து_மாற்று( 0 ) #absolute zero கெல்வின்_இருந்து_மாற்று( 273 ) #freezing pt of water கெல்வின்_இருந்து_மாற்று( 30 + 273 ) #room temperature in Summer </lang>

F#

<lang fsharp> // Define units of measure [<Measure>] type k [<Measure>] type f [<Measure>] type c [<Measure>] type r

// Define conversion functions let kelvinToCelsius (t : float<k>) = ((float t) - 273.15) * 1.0<c> let kelvinToFahrenheit (t : float<k>) = (((float t) * 1.8) - 459.67) * 1.0<f> let kelvinToRankine (t : float<k>) = ((float t) * 1.8) * 1.0<r>

// Example code let K = 21.0<k> printfn "%A Kelvin is %A Celsius" K (kelvinToCelsius K) printfn "%A Kelvin is %A Fahrenheit" K (kelvinToFahrenheit K) printfn "%A Kelvin is %A Rankine" K (kelvinToRankine K) </lang>

Fortran

Works with: Fortran version 90 and later

<lang fortran>Program Temperature 

 implicit none
 
 real :: kel, cel, fah, ran

 write(*,*) "Input Kelvin temperature to convert"
 read(*,*) kel

 call temp_convert(kel, cel, fah, ran)
 write(*, "((a10), f10.3)") "Kelvin", kel
 write(*, "((a10), f10.3)") "Celsius", cel
 write(*, "((a10), f10.3)") "Fahrenheit", fah
 write(*, "((a10), f10.3)") "Rankine", ran

contains

subroutine temp_convert(kelvin, celsius, fahrenheit, rankine) 

 real, intent(in)  :: kelvin
 real, intent(out) :: celsius, fahrenheit, rankine

 celsius = kelvin - 273.15
 fahrenheit = kelvin * 1.8 - 459.67
 rankine = kelvin * 1.8

end subroutine end program</lang>

Go

<lang go>package main

import ( 

   "fmt"
   "os"
   "strconv"

)

func main() { 

   if len(os.Args) != 2 {
       fmt.Println("Usage: k <Kelvin>")
       return
   }
   k, err := strconv.ParseFloat(os.Args[1], 64)
   if err != nil {
       fmt.Println(err)
       return
   }
   if k < 0 {
       fmt.Println("Kelvin must be >= 0.")
       return
   }
   fmt.Printf("K  %.2f\n", k)
   fmt.Printf("C  %.2f\n", k-273.15)
   fmt.Printf("F  %.2f\n", k*9/5-459.67)
   fmt.Printf("R  %.2f\n", k*9/5)

}</lang>

Output:
> k 21
K  21.00
C  -252.15
F  -421.87
R  37.80

Haskell

<lang haskell> main = do 

 putStrLn "Please enter temperature in kelvin: "
 input <- getLine
 let kelvin = read input :: Double
 if
   kelvin < 0.0
 then
   putStrLn "error"
 else
   let
     celsius = kelvin - 273.15
     fahrenheit = kelvin * 1.8 - 459.67
     rankine = kelvin * 1.8
   in do
     putStrLn ("kelvin: " ++ show kelvin)
     putStrLn ("celsius: " ++ show celsius)
     putStrLn ("fahrenheit: " ++ show fahrenheit)
     putStrLn ("rankine: " ++ show rankine)

</lang>

Icon and Unicon

The following program works in both languages: <lang unicon>procedure main(A) 

   k := A[1] | 21.00
   write("K ",k)
   write("C ",k-273.15)
   write("R ",r := k*(9.0/5.0))
   write("F ",r - 459.67)

end</lang>

Sample runs: 

->tc
K 21.0
C -252.15
R 37.8
F -421.87
->tc 273.15
K 273.15
C 0.0
R 491.67
F 32.0
->

J

Solution:<lang j> NB. Temp conversions are all linear polynomials 

  K2K    =:     0    1    NB. K = (1  *k) +   0
  K2C    =:  _273    1    NB. C = (1  *k) - 273
  K2F    =:  _459.67 1.8  NB. F = (1.8*k) - 459.67
  K2R    =:     0    1.8  NB. R = (1.8*k) +   0

  NB.  Do all conversions at once (eval 
  NB.  polynomials in parallel). This is the
  NB.  numeric matrix J programs would manipulate
  NB.  directly.
  k2KCFR =:  (K2K , K2C , K2F ,: K2R) p./ ]</lang>
Example:

<lang j> NB. Format matrix for printing & tag each 

  NB. temp with scale, for human legibility
  fmt    =:  [: (;:inv"1) 0 _1 |: 'KCFR' ;"0 1"_1 '0.2' 8!:0 ]
  kcfr   =:  fmt@k2KCFR
  
  kcfr 21

K 21.00 C -252.00 F -421.87 R 37.80 

  kcfr 0 NB. Absolute zero

K 0.00 C -273.00 F -459.67 R 0.00 

  kcfr 21 100 300  NB. List of temps works fine

K 21.00 100.00 300.00 C -252.00 -173.00 27.00 F -421.87 -279.67 80.33 R 37.80 180.00 540.00</lang> Notes: The approach is founded on polynomials, one for each conversion (e.g. Fahrenheit = 1.8*x - 459.67 where x is measured in degrees Kelvin), and all polynomials are evaluated simultaneously using the built-in p.. Through some code decorations (specifically the / in p./ the "0 1"_1 and the 0 _1 |:), 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).

Java

<lang java>public class TemperatureConversion { 

   public static void main(String args[]) {
       if (args.length == 1) {
           try {
               double kelvin = Double.parseDouble(args[0]);
               if (kelvin >= 0) {
                   System.out.printf("K  %2.2f\n", kelvin);
                   System.out.printf("C  %2.2f\n", kelvinToCelsius(kelvin));
                   System.out.printf("F  %2.2f\n", kelvinToFahrenheit(kelvin));
                   System.out.printf("R  %2.2f\n", kelvinToRankine(kelvin));
               } else {
                   System.out.printf("%2.2f K is below absolute zero", kelvin);
               }
           } catch (NumberFormatException e) {
               System.out.println(e);
           }
       }
   }

   public static double kelvinToCelsius(double k) {
       return k + 273.15;
   }

   public static double kelvinToFahrenheit(double k) {
       return k * 1.8 - 459.67;
   }

   public static double kelvinToRankine(double k) {
       return k * 1.8;
   }

}</lang>

Output:
K  21.00

C  -252.15

F  -421.87

R  37.80

jq

The hard part here is defining round/1 generically.<lang jq>

  1. round(keep) takes as input any jq (i.e. JSON) number and emits a string.
  2. "keep" is the desired maximum number of numerals after the decimal point,
  3. e.g. 9.999|round(2) => 10.00

def round(keep): 

 tostring
 | (index("e") | if . then . else index("E") end) as $e
 | if $e then (.[0:$e] | round(keep)) + .[$e+1:]
   else index(".") as $ix
     | if $ix == null then .
       else .[0:$ix + 1] as $head
         | .[$ix+1:$ix+keep+2] as $tail
         | if ($tail|length) <= keep then $head + $tail
           else ($tail | .[length-1:] | tonumber) as $last
             | if $last < 5 then  $head + $tail[0:$tail|length - 1]
               else (($head + $tail) | length) as $length
                 | ($head[0:-1] + $tail)
                 | (tonumber +  (if $head[0:1]=="-" then -5 else 5 end))
                 | tostring 
                 | .[0: ($ix+1+length-$length)] + "." + .[length-keep-1:-1]
               end
           end
       end
   end;

def k2c: . - 273.15; def k2f: . * 1.8 - 459.67; def k2r: . * 1.8;

  1. produce a stream

def cfr: 

 if . >= 0
 then "Kelvin: \(.)", "Celsius: \(k2c|round(2))",
      "Fahrenheit: \(k2f|round(2))", "Rankine: \(k2r|round(2))"
 else error("cfr: \(.) is an invalid temperature in degrees Kelvin")
 end;

cfr</lang> Example <lang sh> $ jq -M -r -f Temperature_conversion.jq 

 21
 Kelvin: 21
 Celsius: -252.15
 Fahrenheit: -421.87
 Rankine: 37.80
 
 -1
 jq: error: cfr: -1 is an invalid temperature in degrees Kelvin</lang>

Julia

<lang julia>cfr(k) = print("Kelvin: $k, ", 

 "Celsius: $(round(k-273.15,2)), ",
 "Fahrenheit: $(round(k*1.8-459.67,2)), ",
 "Rankine: $(round(k*1.8,2))")</lang>

julia> cfr(21)
Kelvin: 21, Celsius: -252.15, Fahrenheit: -421.87, Rankine: 37.8

Lasso

<lang Lasso>define tempconverter(temp, kind) => {

local( _temp = decimal(#temp), convertratio = 1.8, k_c = 273.15, r_f = 459.67, k,c,r,f )

match(#kind) => { case('k') #k = #_temp #c = -#k_c + #k #r = #k * #convertratio #f = -#r_f + #r case('c') #c = #_temp #k = #k_c + #c #r = #k * #convertratio #f = -#r_f + #r case('r') #r = #_temp #f = -#r_f + #r #k = #r / #convertratio #c = -#k_c + #k case('f') #f = #_temp #r = #r_f + #f #k = #r / #convertratio #c = -#k_c + #k case return 'Something wrong' }

return ('K = ' + #k -> asstring(-precision = 2) + ' C = ' + #c -> asstring(-precision = 2) + ' R = ' + #r -> asstring(-precision = 2) + ' F = ' + #f -> asstring(-precision = 2) ) }

tempconverter(21, 'k') '
' tempconverter(21, 'c') '
' tempconverter(-41, 'c') '
' tempconverter(37.80, 'r') '
' tempconverter(69.80, 'f')</lang> 

K = 21.00 C = -252.15 R = 37.80 F = -421.87
K = 294.15 C = 21.00 R = 529.47 F = 69.80
K = 232.15 C = -41.00 R = 417.87 F = -41.80
K = 21.00 C = -252.15 R = 37.80 F = -421.87
K = 294.15 C = 21.00 R = 529.47 F = 69.80

Lua

<lang lua>function convert_temp(k) 

   local c = k - 273.15
   local r = k * 1.8
   local f = r - 459.67
   return k, c, r, f

end

print(string.format([[ Kelvin: %.2f K Celcius: %.2f °C Rankine: %.2f °R Fahrenheit: %.2f °F ]],convert_temp(21.0)))</lang>

Mathematica

<lang Mathematica>tempConvert[t_] := Grid[Transpose@{{"K", "C", "F", "R"}, Round[{t, t - 273.15, 9 t/5 - 459.67, 9 t/5}, .01]}]

tempConvert[21]</lang>

Output:


K	21.
C	-252.15
F	-421.87
R	37.8

МК-61/52

<lang mk61>П7 0 , 8 * П8 ИП7 9 * 5 / 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 - БП 00</lang>

Instruction:

tºC = РX В/О С/П;

tºRa = РX БП 25 С/П;

tºF = РX БП 32 С/П;

tK = РX БП 42 С/П;

Result:

РX = Р4 = tK;

Р7 = tºC;

Р8 = tºRa;

Р9 = tºF.

ML

mLite

Temperature in Kelvin given on command line. <lang ocaml>fun KtoC n = n - 273.15; fun KtoF n = n * 1.8 - 459.67; fun KtoR n = n * 1.8; val K = argv 0;

if K = false then println "mlite -f temcon.m <temp>" else let val K = ston K in print "Kelvin: "; println K; print "Celcius: "; println ` KtoC K; print "Fahrenheit: "; println ` KtoF K; print "Rankine: "; println ` KtoR K end </lang>


NetRexx

<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols

numeric digits 20

runSample(arg) return

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ /* 

 +  Kelvin               Celsius        Fahrenheit      Rankine             Delisle        Newton            Réaumur        Rømer
 K  T                    T-273.15       T*9/5-459.67    T*9/5               (373.15-T)*3/2 (T-273.15)*33/100 (T-273.15)*4/5 (T-273.15)*21/40+7.5
 C  T+273.15             T              T*9/5+32        (T+273.15)*9/5      (100-T)*3/2    T*33/100          T*4/5          T*21/40+7.5
 F  (T+459.67)*5/9       (T-32)*5/9     T               T+459.67            (212-T)*5/6    (T-32)*11/60      (T-32)*4/9     (T-32)*7/24+7.5
 R  T*5/9                (T-491.67)*5/9 T-459.67        T                   (671.67-T)*5/6 (T-491.67)*11/60  (T-491.67)*4/9 (T-491.67)*7/24+7.5
 De 373.15-T*2/3         100-T*2/3      212-T*6/5       671.67-T*6/5        T              33-T*11/50        80-T*8/15      60-T*7/20
 N  T*100/33+273.15      T*100/33       T*60/11+32      T*60/11+491.67      (33-T)*50/11   T                 T*80/33        T*35/22+7.5
 Ré T*5/4+273.15         T*5/4          T*9/4+32        T*9/4+491.67        (80-T)*15/8    T*33/80           T              T*21/32+7.5
 Rø (T-7.5)*40/21+273.15 (T-7.5)*40/21  (T-7.5)*24/7+32 (T-7.5)*24/7+491.67 (60-T)*20/7    (T-7.5)*22/35     (T-7.5)*32/21  T
*/

method temperatureConversion(scaleFrom, scaleTo, T) public static 

 parse 'KELVIN CELSIUS FAHRENHEIT RANKINE DELISLE NEWTON REAUMUR ROEMER' -
        KELVIN CELSIUS FAHRENHEIT RANKINE DELISLE NEWTON REAUMUR ROEMER .
 scaleFrom = scaleFrom.upper()
 scaleTo   = scaleTo.upper()
 select label sF case scaleFrom
   when KELVIN then do
     select case scaleTo
       when KELVIN     then val = T
       when CELSIUS    then val = T - 273.15
       when FAHRENHEIT then val = T * 9 / 5 - 459.67
       when RANKINE    then val = T * 9 / 5
       when DELISLE    then val = (373.15 - T) * 3 / 2
       when NEWTON     then val = (T - 273.15) * 33 / 100
       when REAUMUR    then val = (T - 273.15) * 4 / 5
       when ROEMER     then val = (T - 273.15) * 21 / 40 + 7.5
       otherwise       signal IllegalArgumentException(scaleFrom',' scaleTo',' T)
       end
     end
   when CELSIUS then do
     select case scaleTo
       when KELVIN     then val = T + 273.15
       when CELSIUS    then val = T
       when FAHRENHEIT then val = T * 9 / 5 + 32
       when RANKINE    then val = (T + 273.15) * 9 / 5
       when DELISLE    then val = (100 - T) * 3 / 2
       when NEWTON     then val = T * 33 / 100
       when REAUMUR    then val = T * 4 / 5
       when ROEMER     then val = T * 21 / 40 + 7.5
       otherwise       signal IllegalArgumentException(scaleFrom',' scaleTo',' T)
       end
     end
   when FAHRENHEIT then do
     select case scaleTo
       when KELVIN     then val = (T + 459.67) * 5 / 9
       when CELSIUS    then val = (T - 32) * 5 / 9
       when FAHRENHEIT then val = T
       when RANKINE    then val = T + 459.67
       when DELISLE    then val = (212 - T) * 5 / 6
       when NEWTON     then val = (T - 32) * 11 / 60
       when REAUMUR    then val = (T - 32) * 4 / 9
       when ROEMER     then val = (T - 32) * 7 / 24 + 7.5
       otherwise       signal IllegalArgumentException(scaleFrom',' scaleTo',' T)
       end
     end
   when RANKINE then do
     select case scaleTo
       when KELVIN     then val = T * 5 / 9
       when CELSIUS    then val = (T - 491.67) * 5 / 9
       when FAHRENHEIT then val = T - 459.67
       when RANKINE    then val = T
       when DELISLE    then val = (671.67 - T) * 5 / 6
       when NEWTON     then val = (T - 491.67) * 11 / 60
       when REAUMUR    then val = (T - 491.67) * 4 / 9
       when ROEMER     then val = (T - 491.67) * 7 / 24 + 7.5
       otherwise       signal IllegalArgumentException(scaleFrom',' scaleTo',' T)
       end
     end
   when DELISLE then do
     select case scaleTo
       when KELVIN     then val = 373.15 - T * 2 / 3
       when CELSIUS    then val = 100 - T * 2 / 3
       when FAHRENHEIT then val = 212 - T * 6 / 5
       when RANKINE    then val = 671.67 - T * 6 / 5
       when DELISLE    then val = T
       when NEWTON     then val = 33 - T * 11 / 50
       when REAUMUR    then val = 80 - T * 8 / 15
       when ROEMER     then val = 60 - T * 7 / 20
       otherwise       signal IllegalArgumentException(scaleFrom',' scaleTo',' T)
       end
     end
   when NEWTON then do
     select case scaleTo
       when KELVIN     then val = T * 100 / 33 + 273.15
       when CELSIUS    then val = T * 100 / 33
       when FAHRENHEIT then val = T * 60 / 11 + 32
       when RANKINE    then val = T * 60 / 11 + 491.67
       when DELISLE    then val = (33 - T) * 50 / 11
       when NEWTON     then val = T
       when REAUMUR    then val = T * 80 / 33
       when ROEMER     then val = T * 35 / 22 + 7.5
       otherwise       signal IllegalArgumentException(scaleFrom',' scaleTo',' T)
       end
     end
   when REAUMUR then do
     select case scaleTo
       when KELVIN     then val = T * 5 / 4 + 273.15
       when CELSIUS    then val = T * 5 / 4
       when FAHRENHEIT then val = T * 9 / 4 + 32
       when RANKINE    then val = T * 9 / 4 + 491.67
       when DELISLE    then val = (80 - T) * 15 / 8
       when NEWTON     then val = T * 33 / 80
       when REAUMUR    then val = T
       when ROEMER     then val = T * 21 / 32 + 7.5
       otherwise       signal IllegalArgumentException(scaleFrom',' scaleTo',' T)
       end
     end
   when ROEMER then do
     select case scaleTo
       when KELVIN     then val = (T - 7.5) * 40 / 21 + 273.15
       when CELSIUS    then val = (T - 7.5) * 40 / 21
       when FAHRENHEIT then val = (T - 7.5) * 24 / 7 + 32
       when RANKINE    then val = (T - 7.5) * 24 / 7 + 491.67
       when DELISLE    then val = (60 - T) * 20 / 7
       when NEWTON     then val = (T - 7.5) * 22 / 35
       when REAUMUR    then val = (T - 7.5) * 32 / 21
       when ROEMER     then val = T
       otherwise       signal IllegalArgumentException(scaleFrom',' scaleTo',' T)
       end
     end
   otherwise
     signal IllegalArgumentException(scaleFrom',' scaleTo',' T)
   end sF

 return val

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method runSample(arg) public static 

 tlist = [ -
 /* C....... F....... K....... R.......*/ -
   ' 5500.00  9932.00  5773.15 10391.67', -
   '  300.00   572.00   573.15  1031.67', -
   '  200.00   392.00   473.15   851.67', -
   '  100.00   212.00   373.15   671.67', -
   '   37.00    98.60   310.15   558.27', -
   '    0.00    32.00   273.15   491.67', -
   ' -100.00  -148.00   173.15   311.67', -
   ' -200.00  -328.00    73.15   131.67', -
   ' -252.15  -421.87    21.00    37.80', -
   ' -273.15  -459.67     0.00     0.00'  -
   ]

 parse 'CELSIUS FAHRENHEIT KELVIN RANKINE' CELSIUS FAHRENHEIT KELVIN RANKINE .
 loop temp over tlist
   parse temp ttC ttF ttK ttR .
   say '   C....... F....... K....... R.......'
   say 'C ' -
       temperatureConversion(CELSIUS,    CELSIUS,    ttC).format(5, 2) -
       temperatureConversion(CELSIUS,    FAHRENHEIT, ttC).format(5, 2) -
       temperatureConversion(CELSIUS,    KELVIN,     ttC).format(5, 2) -
       temperatureConversion(CELSIUS,    RANKINE,    ttC).format(5, 2)
 
   say 'F ' -
       temperatureConversion(FAHRENHEIT, CELSIUS,    ttF).format(5, 2) -
       temperatureConversion(FAHRENHEIT, FAHRENHEIT, ttF).format(5, 2) -
       temperatureConversion(FAHRENHEIT, KELVIN,     ttF).format(5, 2) -
       temperatureConversion(FAHRENHEIT, RANKINE,    ttF).format(5, 2)
 
   say 'K ' -
       temperatureConversion(KELVIN,     CELSIUS,    ttK).format(5, 2) -
       temperatureConversion(KELVIN,     FAHRENHEIT, ttK).format(5, 2) -
       temperatureConversion(KELVIN,     KELVIN,     ttK).format(5, 2) -
       temperatureConversion(KELVIN,     RANKINE,    ttK).format(5, 2)
 
   say 'R ' -
       temperatureConversion(RANKINE,    CELSIUS,    ttR).format(5, 2) -
       temperatureConversion(RANKINE,    FAHRENHEIT, ttR).format(5, 2) -
       temperatureConversion(RANKINE,    KELVIN,     ttR).format(5, 2) -
       temperatureConversion(RANKINE,    RANKINE,    ttR).format(5, 2)
   say
   end temp

 return

</lang>

Output:
   C....... F....... K....... R.......
C   5500.00  9932.00  5773.15 10391.67
F   5500.00  9932.00  5773.15 10391.67
K   5500.00  9932.00  5773.15 10391.67
R   5500.00  9932.00  5773.15 10391.67

   C....... F....... K....... R.......
C    300.00   572.00   573.15  1031.67
F    300.00   572.00   573.15  1031.67
K    300.00   572.00   573.15  1031.67
R    300.00   572.00   573.15  1031.67

   C....... F....... K....... R.......
C    200.00   392.00   473.15   851.67
F    200.00   392.00   473.15   851.67
K    200.00   392.00   473.15   851.67
R    200.00   392.00   473.15   851.67

   C....... F....... K....... R.......
C    100.00   212.00   373.15   671.67
F    100.00   212.00   373.15   671.67
K    100.00   212.00   373.15   671.67
R    100.00   212.00   373.15   671.67

   C....... F....... K....... R.......
C     37.00    98.60   310.15   558.27
F     37.00    98.60   310.15   558.27
K     37.00    98.60   310.15   558.27
R     37.00    98.60   310.15   558.27

   C....... F....... K....... R.......
C      0.00    32.00   273.15   491.67
F      0.00    32.00   273.15   491.67
K      0.00    32.00   273.15   491.67
R      0.00    32.00   273.15   491.67

   C....... F....... K....... R.......
C   -100.00  -148.00   173.15   311.67
F   -100.00  -148.00   173.15   311.67
K   -100.00  -148.00   173.15   311.67
R   -100.00  -148.00   173.15   311.67

   C....... F....... K....... R.......
C   -200.00  -328.00    73.15   131.67
F   -200.00  -328.00    73.15   131.67
K   -200.00  -328.00    73.15   131.67
R   -200.00  -328.00    73.15   131.67

   C....... F....... K....... R.......
C   -252.15  -421.87    21.00    37.80
F   -252.15  -421.87    21.00    37.80
K   -252.15  -421.87    21.00    37.80
R   -252.15  -421.87    21.00    37.80

   C....... F....... K....... R.......
C   -273.15  -459.67     0.00     0.00
F   -273.15  -459.67     0.00     0.00
K   -273.15  -459.67     0.00     0.00
R   -273.15  -459.67     0.00     0.00

Nim

<lang nim>import rdstdin, strutils, strfmt

while true: 

 let k = parseFloat readLineFromStdin "K ? "
 echo "{:g} Kelvin = {:g} Celsius = {:g} Fahrenheit = {:g} Rankine degrees".fmt(
   k, k - 273.15, k * 1.8 - 459.67, k * 1.8)</lang>

Sample usage: 

K ? 21.0
21 Kelvin = -252.15 Celsius = -421.87 Fahrenheit = 37.8 Rankine degrees
K ? 222.2
222.2 Kelvin = -50.95 Celsius = -59.71 Fahrenheit = 399.96 Rankine degrees

Objeck

<lang objeck> class Temperature { 

 function : Main(args : String[]) ~ Nil {
   k := System.IO.Console->ReadString()->ToFloat();
   c := KelvinToCelsius(k);
   f := KelvinToFahrenheit(k);
   r := KelvinToRankine(k);

   "K: {$k}"->PrintLine();
   "C: {$c}"->PrintLine();
   "F: {$f}"->PrintLine();
   "R: {$r}"->PrintLine();
 }

 function : KelvinToCelsius(k : Float) ~ Float {
   return k - 273.15;
 }

 function : KelvinToFahrenheit(k : Float) ~ Float {
   return k * 1.8 - 459.67;
 }

 function : KelvinToRankine(k : Float) ~ Float {
   return k * 1.8;
 }

} </lang> 

K: 21.0
C: -252.150
F: -421.870
R: 37.800

Objective-C

<lang objc>#import <Foundation/Foundation.h>

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

   @autoreleasepool {
       if(argc > 1)
       {
           NSString *arg1 = [NSString stringWithCString:argv[1] encoding:NSUTF8StringEncoding]; 
           // encoding shouldn't matter in this case
           double kelvin = [arg1 doubleValue];
           
           NSLog(@"K %.2f",kelvin);
           NSLog(@"C %.2f\n", kelvin - 273.15);
           NSLog(@"F %.2f\n", (kelvin * 1.8) - 459.67);
           NSLog(@"R %.2f", kelvin * 1.8);
       }
   }
   return 0;

}</lang>

OCaml

<lang ocaml> let print_temp s t = 

 print_string s;
 print_endline (string_of_float t);;

let kelvin_to_celsius k = 

 k -. 273.15;;

let kelvin_to_fahrenheit k = 

 (kelvin_to_celsius k)*. 9./.5. +. 32.00;;

let kelvin_to_rankine k = 

 (kelvin_to_celsius k)*. 9./.5. +. 491.67;;


print_endline "Enter a temperature in Kelvin please:"; let k = read_float () in print_temp "K " k; print_temp "C " (kelvin_to_celsius k); print_temp "F " (kelvin_to_fahrenheit k); print_temp "R " (kelvin_to_rankine k);; </lang>

Sample session: 

Enter a temperature in Kelvin please:
184
K 184.
C -89.15
F -128.47
R 331.2

PARI/GP

<lang parigp>f(x)=[x,x-273.15,1.8*x-459.67,1.8*x]</lang>

Perl

<lang Perl>my %scale = ( 

   Celcius    => { factor => 1  , offset => -273.15 },
   Rankine    => { factor => 1.8, offset =>    0    },
   Fahrenheit => { factor => 1.8, offset => -459.67 },

);

print "Enter a temperature in Kelvin: "; chomp(my $kelvin = <STDIN>); die "No such temperature!\n" unless $kelvin > 0;

foreach (sort keys %scale) { 

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

}</lang>

Output:
Enter a temperature in Kelvin: 21
     Celcius: -252.15
  Fahrenheit: -421.87
     Rankine:   37.80

Perl 6

<lang perl6>while ne my $answer = prompt 'Temperature: ' { 

   my $k = do given $answer {
       when s/:i C $// { $_ + 273.15 }
       when s/:i F $// { ($_ + 459.67) / 1.8 }
       when s/:i R $// { $_ / 1.8 }
       when s/:i K $// { $_ }
       default         { $_ }
   }
   say "  { $k }K";
   say "  { $k - 273.15 }℃";
   say "  { $k * 1.8 - 459.67 }℉";
   say "  { $k * 1.8 }R";

}</lang>

Output:
Temperature: 0
  0K
  -273.15℃
  -459.67℉
  0R
Temperature: 0c
  273.15K
  0℃
  32℉
  491.67R
Temperature: 212f
  373.15K
  100℃
  212℉
  671.67R
Temperature: -40c
  233.15K
  -40℃
  -40℉
  419.67R

PHP

<lang php>error_reporting(E_ALL & ~ ( E_NOTICE | E_WARNING ));

while (true) { 

   echo "\nEnter a value in kelvin (q to quit): ";
   if (($kelvin = trim(fgets(STDIN))) !== false) {
       if ($kelvin == 'q') {
           echo 'quitting';
           break;
       }
       if (is_numeric($kelvin)) {
           $kelvin = floatVal($kelvin);
           if ($kelvin >= 0) {
               printf(" K  %2.2f\n", $kelvin);
               printf(" C  %2.2f\n", $kelvin - 273.15);
               printf(" F  %2.2f\n", $kelvin * 1.8 - 459.67);
               printf(" R  %2.2f\n", $kelvin * 1.8);
           } else printf(" %2.2f K is below absolute zero\n", $kelvin);
       }
   }

}</lang>

Output:
Enter a value in kelvin (q to quit): 21
 K  21.00
 C  -252.15
 F  -421.87
 R  37.80

Enter a value in kelvin (q to quit): q
quitting

PicoLisp

<lang PicoLisp>(scl 2)

(de convertKelvin (Kelvin) 

  (for X
     (quote
        (K . prog)
        (C (K) (- K 273.15))
        (F (K) (- (*/ K 1.8 1.0) 459.67))
        (R (K) (*/ K 1.8 1.0)) )
     (tab (-3 8)
        (car X)
        (format ((cdr X) Kelvin) *Scl) ) ) )</lang>

Test: <lang PicoLisp>(convertKelvin 21.0)</lang>

Output:
K     21.00
C   -252.15
F   -421.87
R     37.80

PL/I

<lang pli>*process source attributes xref; 

/* PL/I **************************************************************
* 15.08.2013 Walter Pachl translated from NetRexx
* temperatures below 0K are considered invalid
*********************************************************************/
temperature: Proc Options(main);
Dcl sysin record Input;
On Endfile(sysin) Goto eoj;
On Record(sysin);
Dcl 1 dat,
     2 t Pic'SSSS9V.99',
     2 *    char( 1),
     2 from char(10),
     2 *    char( 1),
     2 to   char(10);
Do Forever;
  Read File(sysin) Into(dat);
  If tc(t,from,'KELVIN')<0 Then
    Put Edit('Input (',t,from,') invalid. Below absolute zero')
            (Skip,a,f(8,2),x(1),a,a);
  Else
    Put edit(t,from,' -> ',tc(t,from,to),to)
            (skip,f(8,2),x(1),a(10),a,f(8,2),x(1),a(10));
  End;
eoj: Return;

tc: Procedure(T,scaleFrom,scaleTo) Returns(Dec Fixed(8,2));
Dcl t Pic'SSSS9V.99';
Dcl (val) Dec Fixed(8,2);
Dcl (scaleFrom,scaleTo) Char(10);
 select(scaleFrom);
   when('KELVIN ') do;
     select(scaleTo);
       when('KELVIN    ') val = T;
       when('CELSIUS   ') val = T - 273.15;
       when('FAHRENHEIT') val = T * 9 / 5 - 459.67;
       when('RANKINE   ') val = T * 9 / 5;
       when('DELISLE   ') val = (373.15 - T) * 3 / 2;
       when('NEWTON    ') val = (T - 273.15) * 33 / 100;
       when('REAUMUR   ') val = (T - 273.15) * 4 / 5;
       when('ROEMER    ') val = (T - 273.15) * 21 / 40 + 7.5;
       otherwise Do;
         Put Edit('scaleTo=',scaleTo)(Skip,a,a);
         Call err(1);
         End;
       end;
     end;
   when('CELSIUS') do;
     select(scaleTo);
       when('KELVIN    ') val = T + 273.15;
       when('CELSIUS   ') val = T;
       when('FAHRENHEIT') val = T * 9 / 5 + 32;
       when('RANKINE   ') val = (T + 273.15) * 9 / 5;
       when('DELISLE   ') val = (100 - T) * 3 / 2;
       when('NEWTON    ') val = T * 33 / 100;
       when('REAUMUR   ') val = T * 4 / 5;
       when('ROEMER    ') val = T * 21 / 40 + 7.5;
       otherwise Call err(2);
       end;
     end;
   when('FAHRENHEIT') do;
     select(scaleTo);
       when('KELVIN    ') val = (T + 459.67) * 5 / 9;
       when('CELSIUS   ') val = (T - 32) * 5 / 9;
       when('FAHRENHEIT') val = T;
       when('RANKINE   ') val = T + 459.67;
       when('DELISLE   ') val = (212 - T) * 5 / 6;
       when('NEWTON    ') val = (T - 32) * 11 / 60;
       when('REAUMUR   ') val = (T - 32) * 4 / 9;
       when('ROEMER    ') val = (T - 32) * 7 / 24 + 7.5;
       otherwise Call err(3);
       end;
     end;
   when('RANKINE') do;
     select(scaleTo);
       when('KELVIN    ') val = T * 5 / 9;
       when('CELSIUS   ') val = (T - 491.67) * 5 / 9;
       when('FAHRENHEIT') val = T - 459.67;
       when('RANKINE   ') val = T;
       when('DELISLE   ') val = (671.67 - T) * 5 / 6;
       when('NEWTON    ') val = (T - 491.67) * 11 / 60;
       when('REAUMUR   ') val = (T - 491.67) * 4 / 9;
       when('ROEMER    ') val = (T - 491.67) * 7 / 24 + 7.5;
       otherwise Call err(4);
       end;
     end;
   when('DELISLE') do;
     select(scaleTo);
       when('KELVIN    ') val = 373.15 - T * 2 / 3;
       when('CELSIUS   ') val = 100 - T * 2 / 3;
       when('FAHRENHEIT') val = 212 - T * 6 / 5;
       when('RANKINE   ') val = 671.67 - T * 6 / 5;
       when('DELISLE   ') val = T;
       when('NEWTON    ') val = 33 - T * 11 / 50;
       when('REAUMUR   ') val = 80 - T * 8 / 15;
       when('ROEMER    ') val = 60 - T * 7 / 20;
       otherwise Call err(5);
       end;
     end;
   when('NEWTON') do;
     select(scaleTo);
       when('KELVIN    ') val = T * 100 / 33 + 273.15;
       when('CELSIUS   ') val = T * 100 / 33;
       when('FAHRENHEIT') val = T * 60 / 11 + 32;
       when('RANKINE   ') val = T * 60 / 11 + 491.67;
       when('DELISLE   ') val = (33 - T) * 50 / 11;
       when('NEWTON    ') val = T;
       when('REAUMUR   ') val = T * 80 / 33;
       when('ROEMER    ') val = T * 35 / 22 + 7.5;
       otherwise Call err(6);
       end;
     end;
   when('REAUMUR') do;
     select(scaleTo);
       when('KELVIN    ') val = T * 5 / 4 + 273.15;
       when('CELSIUS   ') val = T * 5 / 4;
       when('FAHRENHEIT') val = T * 9 / 4 + 32;
       when('RANKINE   ') val = T * 9 / 4 + 491.67;
       when('DELISLE   ') val = (80 - T) * 15 / 8;
       when('NEWTON    ') val = T * 33 / 80;
       when('REAUMUR   ') val = T;
       when('ROEMER    ') val = T * 21 / 32 + 7.5;
       otherwise Call err(7);
       end;
     end;
   when('ROEMER') do;
     select(scaleTo);
       when('KELVIN    ') val = (T - 7.5) * 40 / 21 + 273.15;
       when('CELSIUS   ') val = (T - 7.5) * 40 / 21;
       when('FAHRENHEIT') val = (T - 7.5) * 24 / 7 + 32;
       when('RANKINE   ') val = (T - 7.5) * 24 / 7 + 491.67;
       when('DELISLE   ') val = (60 - T) * 20 / 7;
       when('NEWTON    ') val = (T - 7.5) * 22 / 35;
       when('REAUMUR   ') val = (T - 7.5) * 32 / 21;
       when('ROEMER    ') val = T;
       otherwise Call err(8);
       end;
     end;
   otherwise Call err(9);
   end;
 return(val);
 err: Proc(e);
 Dcl e Dec fixed(1);
 Put Edit('error ',e,' invalid input')(Skip,a,f(1),a);
 val=0;
 End;
 End;
End;</lang>
Output:
   21.00 KELVIN     ->  -252.15 CELSIUS
   21.00 KELVIN     ->  -421.87 FAHRENHEIT
   21.00 KELVIN     ->    37.80 RANKINE
Input (  600.00 DELISLE   ) invalid. Below absolute zero
Input (   -1.00 KELVIN    ) invalid. Below absolute zero
Input ( -300.00 CELSIUS   ) invalid. Below absolute zero
  212.00 FAHRENHEIT ->   100.00 CELSIUS
    0.00 FAHRENHEIT ->   -17.77 CELSIUS
    0.00 CELSIUS    ->    32.00 FAHRENHEIT
   37.00 CELSIUS    ->    98.60 FAHRENHEIT

Pure Data

temperature.pd 

#N canvas 200 200 640 600 10;
#X floatatom 130 54 8 0 0 2 Kelvin chgk -;
#X obj 130 453 rnd2;
#X floatatom 130 493 8 0 0 1 K - -;
#X floatatom 251 54 8 0 0 2 Celsius chgc -;
#X obj 251 453 rnd2;
#X floatatom 251 493 8 0 0 1 °C - -;
#X floatatom 374 54 8 0 0 2 Fahrenheit chgf -;
#X obj 374 453 rnd2;
#X floatatom 374 493 8 0 0 1 °F - -;
#X floatatom 498 54 8 0 0 2 Rankine chgr -;
#X obj 498 453 rnd2;
#X floatatom 498 493 8 0 0 1 °Ra - -;
#X obj 65 133 - 273.15;
#X obj 65 244 * 1.8;
#X obj 65 267 + 32;
#X obj 65 363 + 459.67;
#X obj 186 133 * 1.8;
#X obj 186 156 + 32;
#X obj 186 268 + 459.67;
#X obj 186 310 / 1.8;
#X obj 309 133 + 459.67;
#X obj 309 215 / 1.8;
#X obj 309 291 - 273.15;
#X obj 433 133 / 1.8;
#X obj 433 223 - 273.15;
#X obj 433 294 * 1.8;
#X obj 433 317 + 32;
#X text 20 53 Input:;
#X text 20 492 Output:;
#X connect 0 0 1 0;
#X connect 0 0 12 0;
#X connect 1 0 2 0;
#X connect 3 0 4 0;
#X connect 3 0 16 0;
#X connect 4 0 5 0;
#X connect 6 0 7 0;
#X connect 6 0 20 0;
#X connect 7 0 8 0;
#X connect 9 0 10 0;
#X connect 9 0 23 0;
#X connect 10 0 11 0;
#X connect 12 0 13 0;
#X connect 12 0 4 0;
#X connect 13 0 14 0;
#X connect 14 0 15 0;
#X connect 14 0 7 0;
#X connect 15 0 10 0;
#X connect 16 0 17 0;
#X connect 17 0 18 0;
#X connect 17 0 7 0;
#X connect 18 0 19 0;
#X connect 18 0 10 0;
#X connect 19 0 1 0;
#X connect 20 0 21 0;
#X connect 20 0 10 0;
#X connect 21 0 22 0;
#X connect 21 0 1 0;
#X connect 22 0 4 0;
#X connect 23 0 24 0;
#X connect 23 0 1 0;
#X connect 24 0 25 0;
#X connect 24 0 4 0;
#X connect 25 0 26 0;
#X connect 26 0 7 0;

Plugin to round the results to at most 2 digits:

rnd.pd 

#N canvas 880 200 450 300 10;
#X obj 77 34 inlet;
#X obj 77 113 * 100;
#X obj 77 135 + 0.5;
#X obj 132 135 < 0;
#X obj 77 172 -;
#X obj 77 194 int;
#X obj 77 216 / 100;
#X obj 77 238 outlet;
#X connect 0 0 1 0;
#X connect 0 0 3 0;
#X connect 1 0 2 0;
#X connect 2 0 4 0;
#X connect 3 0 4 1;
#X connect 4 0 5 0;
#X connect 5 0 6 0;
#X connect 6 0 7 0;

Python

<lang python>>>> while True: k = float(input('K ? ')) print("%g Kelvin = %g Celsius = %g Fahrenheit = %g Rankine degrees."  % (k, k - 273.15, k * 1.8 - 459.67, k * 1.8))


K ? 21.0 21 Kelvin = -252.15 Celsius = -421.87 Fahrenheit = 37.8 Rankine degrees. K ? 222.2 222.2 Kelvin = -50.95 Celsius = -59.71 Fahrenheit = 399.96 Rankine degrees. K ? </lang>

Python: Universal conversion

This converts from any one of the units to all the others <lang python>>>> toK = {'C': (lambda c: c + 273.15), 

          'F': (lambda f: (f + 459.67) / 1.8),
          'R': (lambda r: r / 1.8),
          'K': (lambda k: k) }

>>> while True: magnitude, unit = input('<value> <K/R/F/C> ? ').split() k = toK[unit](float(magnitude)) print("%g Kelvin = %g Celsius = %g Fahrenheit = %g Rankine degrees."  % (k, k - 273.15, k * 1.8 - 459.67, k * 1.8))


<value> <K/R/F/C> ? 222.2 K 222.2 Kelvin = -50.95 Celsius = -59.71 Fahrenheit = 399.96 Rankine degrees. <value> <K/R/F/C> ? -50.95 C 222.2 Kelvin = -50.95 Celsius = -59.71 Fahrenheit = 399.96 Rankine degrees. <value> <K/R/F/C> ? -59.71 F 222.2 Kelvin = -50.95 Celsius = -59.71 Fahrenheit = 399.96 Rankine degrees. <value> <K/R/F/C> ? 399.96 R 222.2 Kelvin = -50.95 Celsius = -59.71 Fahrenheit = 399.96 Rankine degrees. <value> <K/R/F/C> ? </lang>

Racket

Although not exactly the shortest code, the converter function can turn any temperature into any other <lang Racket>#lang racket (define (converter temp init final) 

 (define to-k
   (case init
     ('k temp)
     ('c (+ 273.15 temp))
     ('f (* (+ temp 459.67) 5/9))
     ('r (* temp 5/9))))
 (case final
   ('k to-k)
   ('c (- to-k 273.15))
   ('f (- (* to-k 9/5) 459.67))
   ('r (* to-k 1.8))))

(define (kelvin-to-all temp) 

 (display (format "Kelvin: ~a \nCelsius: ~a \nFahrenheit: ~a \nRankine: ~a \n"
                  temp
                  (converter temp 'k 'c)
                  (converter temp 'k 'f)
                  (converter temp 'k 'r))))

(kelvin-to-all 21)

Kelvin
21
Celsius
-252.14999999999998
Fahrenheit
-421.87
Rankine
37.800000000000004

</lang>

REXX

abridged

This REXX version supports:

  • (alternate spellings with optional   degree   or   degrees   preceding the scale name):
  • alternate temperature scale names
  • supports   any to all   conversions
  • supports   any to any   conversion   (with the   TO   option)
  • support of some common misspellings   (I know what you mean)
  • support of some common temperature scales:
  • Celsius,   centigrade
  • Delisle
  • Fahrenheit
  • kelvin
  • Newton
  • Rankine
  • Reaumur,   Réaumur
  • Romer,   Rømer,   Roemer
  • multiple temperatures in a list
  • specification of which temperature scale to be used for conversion
  • conversion of a temperature to:
  • all other temperature scales
  • a specific temperature scale
  • supports proper pluralization of kelvin
  • comments (annotation notes) allowed within the list
  • aligned output (whole numbers and decimal fractions)

<lang rexx>/*REXX program converts temperatures for a number of temperature scales.*/ numeric digits 120 /*be able to support huge numbers*/ parse arg tList /*get specified temperature lists*/ 

 do  until  tList=                  /*process a list of temperatures.*/
 parse  var tList  x  ','  tList      /*temps are separated by commas. */
 x=translate(x,'((',"[{")             /*support other grouping symbols.*/
 x=space(x);  parse var x z '('       /*handle any comments (if any).  */
 parse upper  var  z  z   ' TO '  ! . /*separate the  TO  option from #*/
 if !==  then !='ALL'; all=!=='ALL' /*allow specification of "TO" opt*/
 if z==     then call serr 'no arguments were specified.'
 _=verify(z, '+-.0123456789')         /*a list of valid number thingys.*/
 n=z
 if _\==0  then do
                if _==1  then call serr 'illegal temperature:'  z
                n=left(z, _-1)        /*pick off the number (hopefully)*/
                u=strip(substr(z, _)) /*pick off the temperature unit. */
                end
           else u='k'                 /*assume  kelvin as per task req.*/

 if \datatype(n,'N')  then call serr 'illegal number:' n
 if \all  then do                     /*there is a    TO  ααα    scale.*/
               call name !            /*process the   TO   abbreviation*/
               !=sn                   /*assign the full name to  !     */
               end                    /* ! now contains scale full name*/
 call name u                          /*allow alternate scale spellings*/

     select                           /*convert ──►  °F  temperatures. */
     when sn=='CELSIUS'          then F=n       *  9/5   +  32
     when sn=='DELISLE'          then F=212 -(n *  6/5)
     when sn=='DELISLE'          then F=212 -(n *  6/5)
     when sn=='FAHRENHEIT'       then F=n
     when sn=='KELVIN'           then F=n       *  9/5   - 459.67
     when sn=='NEWTON'           then F=n       * 60/11  +  32
     when sn=='RANKINE'          then F=n                - 459.67        /*a single  R  is taken as Rankine.*/
     when sn=='REAUMUR'          then F=n       *  9/4   +  32
     when sn=='ROMER'            then F=(n-7.5) * 27/4   +  32
     otherwise          call serr  'illegal temperature scale: '    u
     end   /*select*/

 K = (F + 459.67)  *  5/9             /*compute temperature to kelvins.*/
 say right(' ' x, 79, "─")            /*show original value &scale,sep.*/
 if all | !=='CELSIUS'           then say $(   ( F   -  32     )   *  5/9           )    'Celsius'
 if all | !=='DELISLE'           then say $(   ( 212 -  F      )   *  5/6           )    'Delisle'
 if all | !=='FAHRENHEIT'        then say $(     F                                  )    'Fahrenheit'
 if all | !=='KELVIN'            then say $(        K                               )    'kelvin's(K)
 if all | !=='NEWTON'            then say $(   ( F   -  32     )   *  11/60         )    'Newton'
 if all | !=='RANKINE'           then say $(     F   + 349.67                       )    'Rankine'
 if all | !=='REAUMUR'           then say $(   ( F   -  32     )   *  4/9           )    'Reaumur'
 if all | !=='ROMER'             then say $(   ( F   -  32     )   *  7/24    + 7.5 )    'Romer'
 end   /*until*/

exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────$ subroutine────────────────────────*/ $: procedure; showDig=8 /*only show 8 significant digits.*/ _=format(arg(1), , showDig)/1 /*format # 8 digs past dec point.*/ p=pos(.,_) /*find position of decimal point.*/ 

                                      /* [↓] align integers with FP #s.*/

if p==0 then _=_ || left(,5+showDig+1) /*no decimal point.*/ 

        else _=_ || left(,5+showDig-length(_)+p) /*has    "      "   */

return right(_,50) /*return the re-formatted arg. */ /*──────────────────────────────────name subroutine─────────────────────*/ name: parse arg y /*abbreviations ──► shortname. */ yU=translate(y,'eE',"éÉ"); upper yU /*uppercase version of temp unit.*/ if left(yU,7)=='DEGREES' then yU=substr(yU,8) /*redundant "degrees"? */ if left(yU,6)=='DEGREE' then yU=substr(yU,7) /* " "degree" ? */ yU=strip(yU) /*elide blanks at ends.*/ _=length(yU) /*obtain the yU length.*/ if right(yU,1)=='S' & _>1 then yU=left(yU,_-1) /*elide trailing plural*/ 

     select                           /*abbreviations ──► shortname.   */
     when abbrev('CENTIGRADE' , yU)    |,
          abbrev('CENTRIGRADE', yU)    |,            /* 50% misspelled.*/
          abbrev('CETIGRADE'  , yU)    |,            /* 50% misspelled.*/
          abbrev('CENTINGRADE', yU)    |,
          abbrev('CENTESIMAL' , yU)    |,
          abbrev('CELCIU'     , yU)    |,            /* 82% misspelled.*/
          abbrev('CELCIOU'    , yU)    |,            /*  4% misspelled.*/
          abbrev('CELCUI'     , yU)    |,            /*  4% misspelled.*/
          abbrev('CELSUI'     , yU)    |,            /*  2% misspelled.*/
          abbrev('CELCEU'     , yU)    |,            /*  2% misspelled.*/
          abbrev('CELCU'      , yU)    |,            /*  2% misspelled.*/
          abbrev('CELISU'     , yU)    |,            /*  1% misspelled.*/
          abbrev('CELSU'      , yU)    |,            /*  1% misspelled.*/
          abbrev('CELSIU'     , yU)       then sn='CELSIUS'
     when abbrev('DELISLE'    , yU,2)     then sn='DELISLE'
     when abbrev('FARENHEIT'  , yU)    |,            /* 39% misspelled.*/
          abbrev('FARENHEIGHT', yU)    |,            /* 15% misspelled.*/
          abbrev('FARENHITE'  , yU)    |,            /*  6% misspelled.*/
          abbrev('FARENHIET'  , yU)    |,            /*  3% misspelled.*/
          abbrev('FARHENHEIT' , yU)    |,            /*  3% misspelled.*/
          abbrev('FARINHEIGHT', yU)    |,            /*  2% misspelled.*/
          abbrev('FARENHIGHT' , yU)    |,            /*  2% misspelled.*/
          abbrev('FAHRENHIET' , yU)    |,            /*  2% misspelled.*/
          abbrev('FERENHEIGHT', yU)    |,            /*  2% misspelled.*/
          abbrev('FEHRENHEIT' , yU)    |,            /*  2% misspelled.*/
          abbrev('FERENHEIT'  , yU)    |,            /*  2% misspelled.*/
          abbrev('FERINHEIGHT', yU)    |,            /*  1% misspelled.*/
          abbrev('FARIENHEIT' , yU)    |,            /*  1% misspelled.*/
          abbrev('FARINHEIT'  , yU)    |,            /*  1% misspelled.*/
          abbrev('FARANHITE'  , yU)    |,            /*  1% misspelled.*/
          abbrev('FAHRENHEIT' , yU)       then sn='FAHRENHEIT'
     when abbrev('KALVIN'     , yU)    |,            /* 27% misspelled.*/
          abbrev('KERLIN'     , yU)    |,            /* 18% misspelled.*/
          abbrev('KEVEN'      , yU)    |,            /*  9% misspelled.*/
          abbrev('KELVIN'     , yU)       then sn='KELVIN'
     when abbrev('NEUTON'     , yU)    |,            /*100% misspelled.*/
          abbrev('NEWTON'     , yU)       then sn='NEWTON'
     when abbrev('RANKINE'    , yU, 1)    then sn='RANKINE'
     when abbrev('REAUMUR'    , yU, 2)    then sn='REAUMUR'
     when abbrev('ROEMER'     , yU, 2) |,
          abbrev('ROMER'      , yU, 2)    then sn='ROMER'
     otherwise           call serr  'illegal temperature scale:'  y
     end   /*select*/

return /*──────────────────────────────────one─liner subroutines───────────────*/ s: if arg(1)==1 then return arg(3); return word(arg(2) 's',1) serr: say; say '***error!***'; say; say arg(1); say; exit 13</lang>

Output:

when using the input of

    98.6F to C, -40C, 0 c (water freezes), 37C (body temp), 100 C (water boils), 21 degrees Kelvin, 0K (outer space?) 
───────────────────────────────────────────────────────────────────  98.6F to C
                                  37               Celsius
─────────────────────────────────────────────────────────────────────────  -40C
                                 -40               Celsius
                                 210               Delisle
                                 -40               Fahrenheit
                                 233.15            kelvins
                                 -13.2             Newton
                                 419.67            Rankine
                                 -32               Reaumur
                                 -13.5             Romer
──────────────────────────────────────────────────────────  0 c (water freezes)
                                   0               Celsius
                                 150               Delisle
                                  32               Fahrenheit
                                 273.15            kelvins
                                   0               Newton
                                 491.67            Rankine
                                   0               Reaumur
                                   7.5             Romer
──────────────────────────────────────────────────────────────  37C (body temp)
                                  37               Celsius
                                  94.5             Delisle
                                  98.6             Fahrenheit
                                 310.15            kelvins
                                  12.21            Newton
                                 558.27            Rankine
                                  29.6             Reaumur
                                  26.925           Romer
──────────────────────────────────────────────────────────  100 C (water boils)
                                 100               Celsius
                                   0               Delisle
                                 212               Fahrenheit
                                 373.15            kelvins
                                  33               Newton
                                 671.67            Rankine
                                  80               Reaumur
                                  60               Romer
────────────────────────────────────────────────────────────  21 degrees Kelvin
                                -252.15            Celsius
                                 528.225           Delisle
                                -421.87            Fahrenheit
                                  21               kelvins
                                 -83.2095          Newton
                                  37.8             Rankine
                                -201.72            Reaumur
                                -124.87875         Romer
────────────────────────────────────────────────────────────  0K (outer space?)
                                -273.15            Celsius
                                 559.725           Delisle
                                -459.67            Fahrenheit
                                   0               kelvins
                                 -90.1395          Newton
                                   0               Rankine
                                -218.52            Reaumur
                                -135.90375         Romer

[Actually, water freezes at 0.000089º C,   and boils at 99.974º C.]

unabridged

The REXX program can be seen at ──►   Temperature conversion/REXX

Scientific note:   at temperatures above   1 Planck,   quantum gravitational effects become relevant, and current physical theory breaks down because there is a lack of a theory of quantum gravity.

See the Wikipedia article on Planck temperature:   [[1]].


output when using the input of:   0 Fahrenheit 

─────────────────────────────────────────────────────────────────  0 Fahrenheit
                                            47.67781999      Amonton
                                            -1               Barnsdorf
                                           -14.35292957      Beaumuir
                                           -21.81664121      Benart
                                           -23.8667          Bergen
                                           -15               Brisson
                                           -17.77777778      Celsius
                                             1.67777462      Cimento
                                           992.00031276      Cruquius
                                           -21.85185185      Dalence
                                           -21.57297438      Dalton
                                            -7.70075111      Daniell
                                             3               De la Hire
                                            -6.48011         De la Ville
                                           176.66666667      Delisle
                                           133.67787165      Delisle old
                                           -14               De Luc
                                           -17.5             De Lyon
                                           174.84536082      De Revillas
                                            72.4978          Derham
                                            -1.5             Derham old
                                           -23.7037          De Villeneuve
                                           -17.6666          De Suede
                                           -37.9202          Du Crest
                                             1.37508701      Edinburgh
                                             0.02200631      electron volts
                                             0               Fahrenheit
                                           -89.2727          Fahrenheit old
                                            -7.42857         Florentine large
                                           -73.9736          Florentine Magnum
                                             1.38571         Florentine small
                                           -83.97491258      Fowler
                                           -73.459919        Frick
                                           -10               gas mark
                                            16               Goubert
                                           -26.66666667      Hales
                                            10.000375        Hanow
                                          -122.44444444      Hauksbee
                                           210.7777          Jacobs-Holborn
                                           255.37222222      kelvins
                                           235.222           Leiden
                                            -5.86666667      Newton
                                            16               Oertel
                                             1.80241583E-30  Planck
                                           459.67            Rankine
                                           -14.22222222      Reaumur
                                             3.39999781      Richter
                                            -2.13333333      Rinaldini
                                            -1.83333333      Romer
                                           866.84368889      Rosenthal
                                           122.82            Royal Society of London
                                            15.74512902      Segredo
                                           -44.20787188      Saint-Patrice
                                            -5.71111111      Stufe
                                           -29.00074174      Sulzer
                                            -0.59259259      Thermostat
                                           -11.53701838      Wedgwood

output when using the input of:   0 kelvin 

─────────────────────────────────────────────────────────────────────  0 kelvin
                                            -7.22722761      Amonton
                                           -68.03513851      Barnsdorf
                                          -220.52827751      Beaumuir
                                          -342.38766729      Benart
                                          -452.89203333      Bergen
                                          -230.4703125       Brisson
                                          -273.15            Celsius
                                          -168.14455975      Cimento
                                          -131.1567538       Cruquius
                                          -192.1             Dalence
                                           -infinity         Dalton
                                           -70.91221875      Daniell
                                          -249.38503119      De la Hire
                                          -459.51615256      De la Ville
                                           559.725           Delisle
                                           423.52554742      Delisle old
                                          -215.105625        De Luc
                                          -268.88203125      De Lyon
                                           553.95463918      De Revillas
                                          -104.21950913      Derham
                                          -154.72333333      Derham old
                                          -364.20011547      De Villeneuve
                                          -272.01733333      De Suede
                                          -337.00724352      Du Crest
                                           -97.38098225      Edinburgh
                                             0               electron volts
                                          -459.67            Fahrenheit
                                          -925.03633636      Fahrenheit old
                                          -401.43149281      Florentine large
                                          -766.5078253       Florentine Magnum
                                          -172.63202157      Florentine small
                                          -801.84922875      Fowler
                                          -650.345769        Frick
                                           -28.3868          gas mark
                                          -213.835           Goubert
                                          -409.725           Hales
                                          -420.93486331      Hanow
                                          -760.875           Hauksbee
                                        -1,602.36507778      Jacobs-Holborn
                                             0               kelvins
                                           -20.15022222      Leiden
                                           -90.1395          Newton
                                          -213.835           Oertel
                                             0               Planck
                                             0               Rankine
                                          -218.52            Reaumur
                                          -206.32443969      Richter
                                           -32.778           Rinaldini
                                          -135.90375         Romer
                                           -11.63675556      Rosenthal
                                           757.1646          Royal Society of London
                                        -1,194.54976303      Segredo
                                          -219.57210928      Saint-Patrice
                                           -15.926           Stufe
                                          -430.12644531      Sulzer
                                            -9.105           Thermostat
                                           -21.81059691      Wedgwood

Ruby

<lang ruby>module TempConvert 

 FROM_TEMP_SCALE_TO_K = 
 {'kelvin'     => lambda{|t| t},
  'celsius'    => lambda{|t| t + 273.15},
  'fahrenheit' => lambda{|t| (t + 459.67) * 5/9.0},
  'rankine'    => lambda{|t| t * 5/9.0},
  'delisle'    => lambda{|t| 373.15 - t * 2/3.0},
  'newton'     => lambda{|t| t * 100/33.0 + 273.15},
  'reaumur'    => lambda{|t| t * 5/4.0 + 273.15},
  'roemer'     => lambda{|t| (t - 7.5) * 40/21.0 + 273.15}}

 TO_TEMP_SCALE_FROM_K = 
 {'kelvin'     => lambda{|t| t},
  'celsius'    => lambda{|t| t - 273.15},
  'fahrenheit' => lambda{|t| t * 9/5.0 - 459.67},
  'rankine'    => lambda{|t| t * 9/5.0},
  'delisle'    => lambda{|t| (373.15 - t) * 3/2.0},
  'newton'     => lambda{|t| (t - 273.15) * 33/100.0},
  'reaumur'    => lambda{|t| (t - 273.15) * 4/5.0},
  'roemer'     => lambda{|t| (t - 273.15) * 21/40.0 + 7.5}}
 
 SUPPORTED_SCALES = FROM_TEMP_SCALE_TO_K.keys.join('|')

 def self.method_missing(meth, *args, &block)
   if valid_temperature_conversion?(meth) then
     convert_temperature(meth, *args)
   else
     super
   end
 end

 def self.respond_to_missing?(meth, include_private = false)
   valid_temperature_conversion?(meth) || super
 end

 def self.valid_temperature_conversion?(meth)
   !!(meth.to_s =~ /(#{SUPPORTED_SCALES})_to_(#{SUPPORTED_SCALES})/) 
 end
 
 def self.convert_temperature(meth, temp)
   from_scale, to_scale = meth.to_s.split("_to_")
   return temp.to_f if from_scale == to_scale # no kelvin roundtrip 
   TO_TEMP_SCALE_FROM_K[to_scale].call(FROM_TEMP_SCALE_TO_K[from_scale].call(temp)).round(2)
 end

end</lang> Converts all eight scales to any other scale, by means of method_missing.

Usage: <lang ruby>TempConvert.kelvin_to_celsius 100 #=> -173.15 TempConvert.kelvin_to_fahrenheit 100 #=> -279.67 TempConvert.kelvin_to_rankine 100 #=> 180.0 TempConvert.kelvin_to_delisle 100 #=> 409.73 TempConvert.kelvin_to_newton 100 #=> -57.14 TempConvert.kelvin_to_reaumur 100 #=> -138.52 TempConvert.kelvin_to_roemer 100 #=> -83.4

TempConvert.newton_to_celsius 100 #=> 303.03 TempConvert.newton_to_fahrenheit 100 #=> 577.45

  1. All 64 combinations possible</lang>

Run BASIC

<lang runbasic>[loop] input "Kelvin Degrees";kelvin if kelvin <= 0 then end ' zero or less ends the program celcius = kelvin - 273.15 fahrenheit = kelvin * 1.8 - 459.67 rankine = kelvin * 1.8 print kelvin;" kelvin is equal to ";celcius; " degrees celcius and ";fahrenheit;" degrees fahrenheit and ";rankine; " degrees rankine" goto [loop]</lang>

Scala

Library: Scala

<lang Scala>object TemperatureConversion extends App { 

 def kelvinToCelsius(k: Double) = k + 273.15

 def kelvinToFahrenheit(k: Double) = k * 1.8 - 459.67

 def kelvinToRankine(k: Double) = k * 1.8

 if (args.length == 1) {
   try {
     val kelvin = args(0).toDouble
     if (kelvin >= 0) {
       println(f"K  $kelvin%2.2f")
       println(f"C  ${kelvinToCelsius(kelvin)}%2.2f")
       println(f"F  ${kelvinToFahrenheit(kelvin)}%2.2f")
       println(f"R  ${kelvinToRankine(kelvin)}%2.2f")
     } else println("%2.2f K is below absolute zero", kelvin)

   } catch {
     case e: NumberFormatException => System.out.println(e)
     case e: Throwable => {
       println("Some other exception type:")
       e.printStackTrace()
     }
   }
 } else println("Temperature not given.")

}</lang>

Output:
K  21,00
C  294,15
F  -421,87
R  37,80

Seed7

<lang seed7>$ include "seed7_05.s7i"; 

 include "float.s7i";

const func float: celsius (in float: kelvin) is 

 return kelvin - 273.15;

const func float: fahrenheit (in float: kelvin) is 

 return kelvin * 1.8 - 459.67;

const func float: rankine (in float: kelvin) is 

 return kelvin * 1.8;

const proc: main is func 

 local
   var float: kelvin is 0.0;
 begin
   write("Enter temperature in kelvin: ");
   readln(kelvin);
   writeln("K: " <& kelvin             digits 2 lpad 7);
   writeln("C: " <& celsius(kelvin)    digits 2 lpad 7);
   writeln("F: " <& fahrenheit(kelvin) digits 2 lpad 7);
   writeln("R: " <& rankine(kelvin)    digits 2 lpad 7);
 end func;</lang>
Output:
Enter temperature in kelvin: 21.0
K:   21.00
C: -252.15
F: -421.87
R:   37.80

Tcl

<lang tcl>proc temps {k} { 

   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

}</lang> Demonstrating: <lang tcl>puts -nonewline "Enter a temperature in K: " flush stdout lassign [temps [gets stdin]] k c f r puts [format "K: %.2f" $k] puts [format "C: %.2f" $c] puts [format "F: %.2f" $f] puts [format "R: %.2f" $r]</lang>

Output:
Enter a temperature in K: 21
K: 21.00
C: -252.15
F: -421.87
R: 37.80

XPL0

<lang XPL0>include c:\cxpl\codes; real K, C, F, R; [ChOut(0, ^K); K:= RlIn(0); C:= K - 273.15; ChOut(0, ^C); RlOut(0, C); CrLf(0); F:= 1.8*C + 32.0; ChOut(0, ^F); RlOut(0, F); CrLf(0); R:= F + 459.67; ChOut(0, ^R); RlOut(0, R); CrLf(0); ]</lang>

Output:
K 21
C -252.15000
F -421.87000
R   37.80000

zkl

<lang zkl>K:=ask(0,"Kelvin: ").toFloat(); println("K %.2f".fmt(K)); println("F %.2f".fmt(K*1.8 - 459.67)); println("C %.2f".fmt(K - 273.15)); println("R %.2f".fmt(K*1.8));</lang>

Output:
Kelvin: 373.15
K 373.15
F 212.00
C 100.00
R 671.67

ZX Spectrum Basic

<lang zxbasic>10 REM Translation of traditional basic version 20 INPUT "Kelvin Degrees? ";k 30 IF k <= 0 THEN STOP: REM A value of zero or less will end program 40 LET c = k - 273.15 50 LET f = k * 1.8 - 459.67 60 LET r = k * 1.8 70 PRINT k; " Kelvin is equivalent to" 80 PRINT c; " Degrees Celsius" 90 PRINT f; " Degrees Fahrenheit" 100 PRINT r; " Degrees Rankine" 110 GO TO 20</lang>

Retrieved from "https://rosettacode.org/wiki/Temperature_conversion?oldid=225240"