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:
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>
- 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>
- include <iostream>
- 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
<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
<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>
- 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
<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>
- round(keep) takes as input any jq (i.e. JSON) number and emits a string.
- "keep" is the desired maximum number of numerals after the decimal point,
- 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;
- 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
Oforth
<lang Oforth>: kelvinToCelsius { 273.15 - }
- kelvinToFahrenheit { 1.8 * 459.67 - }
- kelvinToRankine { 1.8 * }
- testTemp(n)
{
n kelvinToCelsius println n kelvinToFahrenheit println n kelvinToRankine println
}</lang>
- Output:
>testTemp(21) -252.15 -421.87 37.8
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 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 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
- 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
<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>
- Programming Tasks
- Solutions by Programming Task
- Lilypond/Omit
- 8th
- Ada
- Aime
- AutoHotkey
- AWK
- BASIC
- BASIC256
- BBC BASIC
- Bracmat
- C
- C++
- C sharp
- Clojure
- COBOL
- Common Lisp
- D
- Delphi
- Erlang
- Euphoria
- Excel
- Ezhil
- F Sharp
- Fortran
- Go
- Haskell
- Icon
- Unicon
- J
- Java
- Jq
- Julia
- Lasso
- Lua
- Mathematica
- МК-61/52
- ML
- MLite
- NetRexx
- Nim
- Objeck
- Objective-C
- OCaml
- Oforth
- PARI/GP
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- Pure Data
- Python
- Racket
- REXX
- Ruby
- Run BASIC
- Scala
- Seed7
- Tcl
- XPL0
- Zkl
- ZX Spectrum Basic