Temperature conversion

From Rosetta Code
Revision as of 21:58, 13 August 2013 by Grondilu (talk | contribs) (spelling is dubious, to say the least)
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 Celcius and Kelvin scales have the same magnitude, but different null points.

0 degrees Celcius 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 Celcius/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

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_byte(symbol);
   o_space(1);
   o_wpreal(8, 2, 2, temperature);
   o_newline();

}

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

AWK

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

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 CELCIUS" 90 PRINT F; " DEGREES FAHRENHEIT" 100 PRINT R; " DEGREES RANKINE" 110 GOTO 20</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

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 ) << "CELCIUS:" << 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:
===============
CELCIUS:     100
DELISLE:     0
FAHRENHEIT:  212
KELVIN:      373.15
NEWTON:      33
RANKINE:     671.67
REAUMUR:     80
ROMER:       60

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

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

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

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 

  fmt    =:  '0.2' 8!:0 k2KCFR

  NB.  Tag each temp with scale, for human
  NB.  legibility.
  kcfr   =:  0 _1 |: 'KCFR' ,"0 1"_1 >@:fmt
  
  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 C-252.00 F-421.87 R 37.80

K 100.00 C-173.00 F-279.67 R 180.00

K 300.00 C 27.00 F 80.33 R 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", kelvinToCelcius(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 kelvinToCelcius(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

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

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.

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

Objeck

<lang objeck> class Temperature { 

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

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

 function : KelvinToCelcius(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>

PARI/GP

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

Perl

<lang Perl>#!/usr/bin/perl use strict ; use warnings ;

sub kelvin_to_other_scales { 

  my $kelvin = shift ;
  my $celsius = $kelvin - 273.15 ;
  my $rankine = 9 * $kelvin / 5 ;
  my $fahrenheit = $rankine - 459.67 ;
  my @scales ;
  push @scales , $kelvin , $celsius , $fahrenheit , $rankine ;
  return @scales ;

}

print "Enter a temperature in Kelvin: " ; my $kelvin = <STDIN> ; chomp $kelvin ; while ( $kelvin < 0 ) { 

  print "Error! There are no negative kelvin degrees!\n" ;
  $kelvin = <STDIN> ;
  chomp $kelvin ;

} my @scales = kelvin_to_other_scales( $kelvin ) ; print "K $scales[ 0 ]\n" ; print "C $scales[ 1 ]\n" ; print "F $scales[ 2 ]\n" ; print "R $scales[ 3 ]\n" ;</lang>

Output:
Enter a temperature in Kelvin: 21
K 21
C -252.15
F -421.87
R 37.8

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

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

Althoguh 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

This REXX version supports:

  • (alternate spellings with optional   degrees):
    • centigrade, centingrade, centesimal, Celsius, Celcius
    • Delisle
    • Fahrenheit
    • Kelvin
    • Newton
    • Rankine
    • Reaumur, Réaumur
    • Romer   (Rømer),   Roemer
  • multiple temperatures in a list
  • specification of which temperature to be used for conversion
  • conversion of a temperature to all other eight temperatures
  • comments within the list
  • aligned output (whole numbers and decimal fractions)

<lang rexx>/*REXX program converts temperature for: C, D, F, N, Ra, Re, Ro, and K.*/ 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=space(x);  parse var x z '('       /*handle any comments (if any).  */
 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.*/

 uU=translate(u,'eE',"éÉ");  upper uU /*uppercase version of temp unit.*/
 if left(uU,7)=='DEGREES' then uU=substr(uU,8)  /*redundant "degrees"? */
 if left(uU,5)=='DEGREE'  then uU=substr(uU,7)  /*   "      "degree" ? */
 uU=strip(uU)
 if \datatype(n,'N')  then call serr 'illegal number:' n
                                      /*accept alternate spellings.    */
     select                           /*convert ──►  ºF  temperatures. */
     when abbrev('CENTIGRADE', uU)    |,
          abbrev('CENTINGRADE',uU)    |, 
          abbrev('CENTESIMAL', uU)    |,
          abbrev('CELSIUS'   , uU)    |,
          abbrev('CELCIUS'   , uU)       then F=n       *  9/5   +  32
     when abbrev('DELISLE'   , uU)       then F=212 -(n *  6/5)
     when abbrev('FAHRENHEIT', uU)       then F=n
     when abbrev('KELVIN'    , uU)       then F=n       *  9/5   - 459.67
     when abbrev('NEWTON'    , uU)       then F=n       * 60/11  +  32
     when abbrev('RANKINE'   , uU)       then F=n                - 459.67
     when abbrev('REAUMUR'   , uU, 2)    then F=n       *  9/4   +  32
     when abbrev('ROEMER'    , uU, 2) |,
          abbrev('ROMER'     , uU, 2)    then F=(n-7.5) * 27/4   +  32
     otherwise          call serr  'illegal temperature scale:'  u
     end   /*select*/
                                                  say right(' ' x,55,"─")
 say Tform( ( F   - 32     )   *  5/9           )    'Celcius'
 say Tform( ( 212 - F      )   *  5/6           )    'Delisle'
 say Tform(   F                                 )    'Fahrenheit'
 say Tform( ( F   + 459.67 )   *  5/9           )    'Kelvin'
 say Tform( ( F   - 32     )   *  11/60         )    'Newton'
 say Tform(   F   + 459.67                      )    'Rankine'
 say Tform( ( F   - 32     )   *  4/9           )    'Reaumur'
 say Tform( ( F   - 32     )   *  7/24    + 7.5 )    'Romer'
 end   /*until tlist=*/

exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────TFORM subroutine────────────────────*/ Tform: procedure; showDig=8; _=format(arg(1),,showDig)/1; p=pos('.',_) if p==0 then _=_ || left(,showDig+1) 

        else _=_ || left(,showDig-length(_)+p);      return right(_,20)

/*──────────────────────────────────SERR subroutine─────────────────────*/ serr: say; say '***error!***'; say; say arg(1); say; exit 13</lang> output when using the input of: -40C, 0 c (water freezes), 37C (body temp), 100 C (water boils), 21 degrees Kelvin, 0K (outer space?) 

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

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

Run BASIC

<lang runbasic>[loop] input "Lelvin 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>

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

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 Celcius" 90 PRINT f; " Degrees Fahrenheit" 100 PRINT r; " Degrees Rankine" 110 GO TO 20</lang>

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