Temperature conversion: Difference between revisions

{{omit from|Lilypond}}

 

 

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

 

 

 

 

 

<pre>

K 21.00

 

R 37.80

</pre>

 

=={{header|360 Assembly}}==

{{trans|AWK}}

TEMPERAT CSECT

USING TEMPERAT,R15

EDMASKN DC X'402021204B202060' CL8 5num

YREGS

{{out}}

<pre>

 

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

;

 

: KtoF \ n -- n

;

 

: KtoR \ n -- n

;

 

: KtoCFR \ n --

;

 

: app:main \

;

{{out}}

<pre>>8th temp.8th 21

-421.87000 degrees Fahrenheit

37.80000 degrees Rankine

</pre>

 

=={{header|Ada}}==

 

 

procedure Temperatur_Conversion is

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

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

 

{{out}}

 

=={{header|Aime}}==

show(integer symbol, real temperature)

{

 

return 0;

{{out}}

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

 

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

BEGIN

REAL kelvin;

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

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

{{out}}

<pre>$ echo 21 | a68g Temperature_conversion.a68

+21.00 K = -421.87 F

$ </pre>

 

=={{header|AutoHotkey}}==

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

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

{

return, round(k * 1.8, 2)

{{out}}

<pre>Kelvin: 21.00 K

Fahrenheit: -421.87 F

Rankine: 37.80 R</pre>

 

=={{header|AWK}}==

"Interactive" version, reading from stdin only:

BEGIN {

while (1) {

}

if (K < 0) {

continue

}

}

exit(0)

 

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

 

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

 

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

 

END { print("# Bye.") }

 

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

 

=={{header|BASIC}}==

20 INPUT "KELVIN DEGREES",K

30 IF K <= 0 THEN END: REM A VALUE OF ZERO OR LESS WILL END PROGRAM

90 PRINT F; " DEGREES FAHRENHEIT"

100 PRINT R; " DEGREES RANKINE"

 

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

input K

print "C = " + string(K - 273.15)

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

 

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

UNTIL K>=0

PRINT "F = " K * 1.8 - 459.67

PRINT "R = " K * 1.8

{{out}}

 

K = 21.00

C = -252.15

F = -421.87

 

=={{header|Befunge}}==

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

 

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

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

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

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

 

{{out}}

 

=={{header|Bracmat}}==

= minus fixedpointnumber number decimals

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

)

& done!

{{out}}

<pre>Enter Kelvin temperature:21.00

 

=={{header|C}}==

#include <stdlib.h>

 

}

return 0;

 

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

#include <iostream>

#include <iomanip>

public:

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

 

void convert( float kelvin )

{

 

private:

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

while( true )

{

}

return 0;

}

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

{{out}}

<pre>

</pre>

 

 

}

 

=={{header|Clojure}}==

{{trans|Common Lisp}}

(- k 273.15))

(defn to-fahrenheit [k]

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

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

 

{{out}}

"Celsius: -252.15 Fahrenheit: -421.87 Rankine: 37.80"

</pre>

 

=={{header|COBOL}}==

{{works with|Visual COBOL}}

PROGRAM-ID. temp-conversion.

GOBACK

 

{{out}}

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

 

(defun to-celsius (k)

(- k 273.15))

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

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

 

{{out}}

 

=={{header|D}}==

return k - 273.15;

}

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

}

{{out}}

<pre>

R 37.80

</pre>

 

=={{header|Delphi}}==

program Temperature;

 

readln;

end.

{{out}}

<pre>

F: -421.87

R: 37.80

</pre>

 

=={{header|Elixir}}==

def conversion(t) do

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

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module(temp_conv).

-export([main/0]).

 

main() ->

 

conversion(T) ->

 

f(A) ->

{{out}}

<pre>

 

=={{header|Euphoria}}==

include std/console.e

 

atom K

while 1 do

end while

{{out}}

<pre>

 

=={{header|Excel}}==

B1 : Celsius

C1 : Fahrenheit

C2 : =K*1.8-459.67

D2 : =K*1.8

{{Out}}

<pre>

2 21 -252.15 -421.87 37.8

</pre>

 

=={{header|Ezhil}}==

# convert from Kelvin

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

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

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

 

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

// Define units of measure

[<Measure>] type k

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

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

 

=={{header|Fortran}}==

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

implicit none

 

end subroutine

 

=={{header|Go}}==

 

import (

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

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

{{out}}

<pre>

F -421.87

R 37.80

</pre>

 

=={{header|Haskell}}==

 

main = do

putStrLn "Please enter temperature in kelvin: "

input <- getLine

 

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

 

The following program works in both languages:

k := A[1] | 21.00

write("K ",k)

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

write("F ",r - 459.67)

 

Sample runs:

->

</pre>

 

=={{header|J}}==

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

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

NB. numeric matrix J programs would manipulate

NB. directly.

{{out|Example}}

NB. temp with scale, for human legibility

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

C -252.00 -173.00 27.00

F -421.87 -279.67 80.33

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

 

=={{header|Java}}==

public static void main(String args[]) {

if (args.length == 1) {

 

public static double kelvinToCelsius(double k) {

}

 

return k * 1.8;

}

{{out}}

<pre>

R 37.80

</pre>

=={{header|JavaScript}}==

var k2r = k => k * 1.8

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

 

Number.prototype.toMaxDecimal = function (d) {

}

 

function kCnv(k) {

}

kCnv(21)

{{out}}

<pre>

295K° = 21.85C° = 531R° = 71.33F°

</pre>

 

=={{header|jq}}==

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

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

end;

 

'''Example'''

21

Kelvin: 21

-1

 

=={{header|Julia}}==

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

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

<pre>julia> cfr(21)

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

 

=={{header|Lasso}}==

 

 

 

}

 

tempconverter(37.80, 'r')

'<br />'

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

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

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

K = 294.15 C = 21.00 R = 529.47 F = 69.80</pre>

 

=={{header|Lua}}==

 

local c = k - 273.15

local r = k * 1.8

Rankine: %.2f °R

Fahrenheit: %.2f °F

 

 

{{out}}<pre>

</pre>

 

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

 

''Instruction:''

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

Temperature in Kelvin given on command line.

fun KtoF n = n * 1.8 - 459.67;

fun KtoR n = n * 1.8;

 

if K = false then

else

 

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols

 

 

return

{{out}}

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

K -273.15 -459.67 0.00 0.00

R -273.15 -459.67 0.00 0.00

</pre>

 

=={{header|NewLISP}}==

(define (to-celsius k)

(- k 273.15)

)

)

{{out}}

<pre>

 

=={{header|Nim}}==

 

while true:

let k = parseFloat readLineFromStdin "K ? "

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

Sample usage:

<pre>K ? 21.0

 

=={{header|Objeck}}==

class Temperature {

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

}

}

 

<pre>

 

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

 

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

}

return 0;

 

=={{header|OCaml}}==

let print_temp s t =

print_string s;

print_temp "F " (kelvin_to_fahrenheit k);

print_temp "R " (kelvin_to_rankine k);;

 

Sample session:

 

=={{header|Oforth}}==

 

: testTemp(n)

n kelvinToCelsius println

n kelvinToFahrenheit println

 

{{out}}

<pre>

-252.15

-421.87

37.8

</pre>

 

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

 

=={{header|Pascal}}==

 

type

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

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

 

{{out}}

 

=={{header|Perl}}==

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

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

foreach (sort keys %scale) {

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

{{out}}

<pre>

</pre>

 

{{out}}

 

=={{header|PHP}}==

 

while (true) {

echo "\nEnter a value in kelvin (q to quit): ";

if ($kelvin == 'q') {

echo 'quitting';

}

}

{{out}}

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

 

=={{header|PicoLisp}}==

 

(de convertKelvin (Kelvin)

(tab (-3 8)

(car X)

Test:

{{out}}

<pre>K 21.00

 

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

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

* 15.08.2013 Walter Pachl translated from NetRexx

End;

End;

{{out}}

<pre>

37.00 CELSIUS -> 98.60 FAHRENHEIT

</pre>

=={{header|PowerShell}}==

{{trans|Tcl}}

 

 

}

 

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

{{Out}}

<pre>PS> ./TEMPS

PS></pre>

 

 

<pre>

#X floatatom 130 54 8 0 0 2 Kelvin chgk -;

#X obj 130 453 rnd2;

#X connect 24 0 4 0;

#X connect 25 0 26 0;

Plugin to round the results to at most 2 digits:

 

'''rnd.pd'''

#X obj 77 34 inlet;

#X obj 77 113 * 100;

#X connect 4 0 5 0;

#X connect 5 0 6 0;

 

=={{header|Python}}==

 

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.

 

===Python: Universal conversion===

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

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

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

'K': (lambda k: k) }

>>> while True:

 

<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> ? 399.96 R

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

 

=={{header|Racket}}==

Although not exactly the shortest code,

the converter function can turn any temperature into any other

(define (converter temp init final)

(define to-k

;Fahrenheit: -421.87

;Rankine: 37.800000000000004

 

=={{header|REXX}}==

::* supports &nbsp; ''any to all'' &nbsp; conversions

::* supports &nbsp; ''any to any'' &nbsp; conversion &nbsp; (with the &nbsp; '''TO''' &nbsp; option)

::* support of some common temperature scales:

::::::* Celsius, &nbsp; centigrade

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

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

 

if _\==0 then do

end

 

 

end /*select*/

 

if all | !=='CELSIUS' then say $( ( F - 32 ) * 5/9 ) 'Celsius'

if all | !=='DELISLE' then say $( ( 212 - F ) * 5/6 ) 'Delisle'

if all | !=='KELVIN' then say $( K ) 'kelvin's(K)

if all | !=='NEWTON' then say $( ( F - 32 ) * 11/60 ) 'Newton'

if all | !=='REAUMUR' then say $( ( F - 32 ) * 4/9 ) 'Reaumur'

end /*until*/

 

<pre>

─────────────────────────────────────────────────────────────────── 98.6F to C

419.67 Rankine

-32 Reaumur

────────────────────────────────────────────────────────── 0 c (water freezes)

0 Celsius

558.27 Rankine

29.6 Reaumur

────────────────────────────────────────────────────────── 100 C (water boils)

100 Celsius

671.67 Rankine

80 Reaumur

──────────────────────────────────────────────────────────── 21 degrees Kelvin

-252.15 Celsius

37.8 Rankine

-201.72 Reaumur

-273.15 Celsius

559.725 Delisle

0 Rankine

-218.52 Reaumur

</pre>

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

===unabridged===

 

 

 

<br>

 

<pre>

───────────────────────────────────────────────────────────────── 0 Fahrenheit

47.67781999 Amonton

-1 Barnsdorf

-6.48011 De la Ville

176.66666667 Delisle

-14 De Luc

-17.5 De Lyon

174.84536082 De Revillas

72.4978 Derham

-23.7037 De Villeneuve

-17.6666 De Suede

0.02200631 electron volts

0 Fahrenheit

-7.42857 Florentine large

-73.9736 Florentine Magnum

3.39999781 Richter

-2.13333333 Rinaldini

866.84368889 Rosenthal

122.82 Royal Society of London

-11.53701838 Wedgwood

</pre>

<pre>

───────────────────────────────────────────────────────────────────── 0 kelvin

-7.22722761 Amonton

-68.03513851 Barnsdorf

-459.51615256 De la Ville

559.725 Delisle

-215.105625 De Luc

-268.88203125 De Lyon

553.95463918 De Revillas

-104.21950913 Derham

-364.20011547 De Villeneuve

-272.01733333 De Suede

0 electron volts

-459.67 Fahrenheit

-401.43149281 Florentine large

-766.5078253 Florentine Magnum

-206.32443969 Richter

-32.778 Rinaldini

-11.63675556 Rosenthal

757.1646 Royal Society of London

-9.105 Thermostat

-21.81059691 Wedgwood

</pre>

 

=={{header|Ruby}}==

 

FROM_TEMP_SCALE_TO_K =

end

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

 

Usage:

TempConvert.kelvin_to_fahrenheit 100 #=> -279.67

TempConvert.kelvin_to_rankine 100 #=> 180.0

TempConvert.newton_to_celsius 100 #=> 303.03

TempConvert.newton_to_fahrenheit 100 #=> 577.45

 

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

input "Kelvin Degrees";kelvin

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

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

 

=={{header|Scala}}==

{{libheader|Scala}}

 

def kelvinToCelsius(k: Double) = k + 273.15

}

} else println("Temperature not given.")

{{out}}

<pre>

F -421,87

R 37,80

</pre>

 

=={{header|Seed7}}==

include "float.s7i";

 

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

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

 

{{out}}

R: 37.80

</pre>

 

=={{header|Tcl}}==

set c [expr {$k - 273.15}]

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

set f [expr {$r - 459.67}]

list $k $c $f $r

Demonstrating:

flush stdout

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

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

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

{{out}}

<pre>

R: 37.80

</pre>