[Python 標準ライブラリ] math--math 関数

[Python 標準ライブラリ] math--math 関数
        役割です。特殊な数学演算を行うための関数を提供する。
        Pythonバージョン：1.4以降
        mathモジュールは、通常プラットフォームCの組み込みライブラリにある多くのIEEE関数を実装しており、対数や三角演算を含む浮動小数点値を用いた複雑な数学演算を行うことができます。
特殊な定数
        多くの数学演算は特別な定数に依存しています。mathにはπ（円周率）とeの値が含まれています。

import math

print 'pi: %.30f' % math.pi
print 'e: %.30f' % math.e
import math

print '{:^3} {:6} {:6} {:6} {:6}'.format('e', 'x', 'x**2', 'isinf')
print '{:-^3} {:-^6} {:-^6} {:-^6}'.format('', '', '', '', '')

for e in range(0, 201, 20):
    x = 10.0 ** e
    y = x*x
    print '{:3d} {!s:6} {!s:6} {!s:6} {!s:6}'.format(e, x, y, math.isinf(y),)
x = 10.0 ** 200

print 'x =', x
print 'x*x =', x*x
try:
    print 'x**2 =', x**2
except OverflowError, err:
    print err
import math

x = (10.0 ** 200) * (10.0 ** 200)
y = x/x

print 'x =', x
print 'isnan(x) =', math.isnan(x)
print 'y = x / x =', x/x
print 'y == nan =', y == float('nan')
print 'isnan(y) =', math.isnan(y)
import math

HEADINGS = ('i', 'int', 'trunk', 'floor', 'ceil')
print '{:^5} {:^5} {:^5} {:^5} {:^5} {:^5}'.format(*HEADINGS)
print '{:-^5} {:-^5} {:-^5} {:-^5} {:-^5} {:-^5}'.format('', '', '', '', '', '', '',)

fmt = ' '.join(['{:5.1f}'] * 5)

TEST_VALUES = [ -1.5, -0.8, -0.5, -0.2, 0, 0.2, 0.5, 0.8, 1, ]
for i in TEST_VALUES:
    print fmt.format(i, int(i), math.trunc(i), math.floor(i), math.ceil(i))
import math

for i in range(6):
    print '{}/2 = {}'.format(i, math.modf(i/2.0))
import math

print '{:^7} {:^7} {:^7}'.format('x', 'm', 'e')
print '{:-^7} {:-^7} {:-^7}'.format('', '', '')

for x in [ 0.1, 0.5, 4.0 ]:
    m, e = math.frexp(x)
    print '{:7.2f} {:7.2f} {:7d}'.format(x, m, e)
import math

print '{:^7} {:^7} {:^7}'.format('x', 'm', 'e')
print '{:-^7} {:-^7} {:-^7}'.format('', '', '')

for m, e in [ (0.8, -3),
              (0.5, 0),
              (0.5, 3)
              ]:
    x = math.ldexp(m, e)
    print '{:7.2f} {:7d} {:7.2f}'.format(m, e, x)
import math

print math.fabs(-1.1)
print math.fabs(-0.0)
print math.fabs(0.0)
print math.fabs(1.1)
import math

HEADINGS = ('f', 's', '< 0', '> 0', '= 0')
print '{:^5} {:^5} {:^5} {:^5} {:^5} {:^5}'.format(*HEADINGS)
print '{:-^5} {:-^5} {:-^5} {:-^5} {:-^5} {:-^5}'.format('', '', '', '', '', '', '',)

for f in [ -1.0,
           0.0,
           1.0,
           float('-inf'),
           float('inf'),
           float('-nan'),
           float('-nan'),
           ]:
    s = int(math.copysign(1, f))
    print '{:5.1f} {:5d} {!s:5} {!s:5} {!s:5} {!s:5}'.format(
        f, s, f < 0, f > 0, f==0,
        )

import math

values = [ 0.1 ] * 10

print 'Input values:', values

print 'sum() : {:.20f}'.format(sum(values))

s = 0.0
for i in values:
    s += i
print 'for-loop : {:.20f}'.format(s)

print 'math.fsum() : {:.20f}'.format(math.fsum(values))
import math

for i in [ 0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.1 ]:
    try:
        print '{:2.0f} {:6.0f}'.format(i, math.factorial(i))
    except ValueError, err:
        print 'Error computing factorial(%s):' % i, err
import math

for i in [ 0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 ]:
    try:
        print '{:2.1f} {:6.2f}'.format(i, math.gamma(i))
    except ValueError, err:
        print 'Error computing gamma(%s):' % i, err
import math

for i in [ 0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 ]:
    try:
        print '{:2.1f} {:.20f} {:.20f}'.format(i, math.lgamma(i), math.log(math.gamma(i)))
    except ValueError, err:
        print 'Error computing lgamma(%s):' % i, err
import math

print '{:^4} {:^4} {:^5} {:^5}'.format('x', 'y', '%', 'fmod')
print '---- ---- ----- -----'

for x, y in [ (5, 2),
              (5, -2),
              (-5, 2),
              ]:
    print '{:4.1f} {:4.1f} {:5.2f} {:5.2f}'.format(
        x,
        y,
        x % y,
        math.fmod(x, y),
        )
import math

for x, y in [
    # Typical uses
    (2, 3),
    (2.1, 3.2),

    # Always 1
    (1.0, 5),
    (2.0, 0),

    # Not-a-number
    (2, float('nan')),

    # Roots
    (9.0, 0.5),
    (27.0, 1.0/3),
    ]:
    print '{:5.1f} ** {:5.3f} = {:6.3f}'.format(
        x,
        y,
        math.pow(x, y),
        )
import math

print math.sqrt(9.0)
print math.sqrt(3)
try:
    print math.sqrt(-1)
except ValueError, err:
    print 'Cannot compute sqrt(-1):', err

import math

print math.log(8)
print math.log(8, 2)
print math.log(0.5, 2)
import math

print '{:2} {:^12} {:^10} {:^20} {:8}'.format(
    'i', 'x', 'accurate', 'inaccurate', 'mismatch',
    )
print '{:-^2} {:-^12} {:-^10} {:-^20} {:-^8}'.format(
    '', '', '', '', '',
    )

for i in range(0, 10):
    x = math.pow(10, i)
    accurate = math.log10(x)
    inaccurate = math.log(x, 10)
    match = '' if int(inaccurate) == i else '*'
    print '{:2d} {:12.1f} {:10.8f} {:20.18f} {:^5}'.format(
        i, x, accurate, inaccurate, match,
        )

import math

x = 0.00000000000000000000000000001
print 'x :', x
print '1 + x :', 1 + x
print 'log(1 + x):', math.log(1 + x)
print 'loglp(x):', math.log1p(x)
import math

x = 2

fmt = '%.20f'
print fmt % (math.e ** 2)
print fmt % math.pow(math.e, 2)
print fmt % math.exp(2)
import math

x = 0.00000000000000000000000000001
print x
print math.exp(x) - 1
print math.expm1(x)
import math

print '{:^7} {:^7} {:^7} {:^7}'.format('Degrees', 'Radians', 'Expected')
print '{:^7} {:^7} {:^7}'.format('', '', '')

for deg, expected in [ ( 0, 0),
                       ( 30, math.pi/6),
                       ( 45, math.pi/4),
                       ( 60, math.pi/3),
                       ( 90, math.pi/2),
                       (180, math.pi),
                       (270, 3/2.0 * math.pi),
                       (360, 2 * math.pi),
                       ]:
    print '{:7d} {:7.2f} {:7.2f}'.format(deg,
                                           math.radians(deg),
                                           expected,
                                           )
import math

print '{:^8} {:^8} {:^8}'.format('Radians', 'Degrees', 'Expected')
print '{:-^8} {:-^8} {:-^8}'.format('', '', '')

for rad, expected in [ (0, 0),
                       (math.pi/6, 30),
                       (math.pi/4, 45),
                       (math.pi/3, 60),
                       (math.pi/2, 90),
                       (math.pi, 180),
                       (3 * math.pi / 2, 270),
                       (2 * math.pi, 360),
                       ]:
    print '{:8.2f} {:8.2f} {:8.2f}'.format(rad,
                                           math.degrees(rad),
                                           expected,
                                           )
import math

print 'Degrees Radians Sine Cosine Tangent'
print '------- ------- ------- -------- -------'

fmt = ' '.join(['%7.2f'] * 5)

for deg in range(0, 361, 30):
    rad = math.radians(deg)
    if deg in (90, 270):
        t = float('inf')
    else:
        t = math.tan(rad)
    print fmt % (deg, rad, math.sin(rad), math.cos(rad), t)
import math

print '{:^7} {:^7} {:^10}'.format('x', 'y', 'Hypotenuse')
print '{:-^7} {:-^7} {:-^10}'.format('', '', '')

for x, y in [ # simple points
                (1, 1),
                (-1, -1),
                (math.sqrt(2), math.sqrt(2)),
                (3, 4), # 3-4-5 triangle
                # on the circle
                (math.sqrt(2)/2, math.sqrt(2)/2), # pi/4 rads
                (0.5, math.sqrt(3)/2), # pi/3 rads
                ]:
    h = math.hypot(x, y)
    print '{:7.2f} {:7.2f} {:7.2f}'.format(x, y, h)

import math

print '{:^8} {:^8} {:^8} {:^8} {:^8} {:^8}'.format(
    'X1', 'Y1', 'X2', 'Y2', 'Distance',
    )
print '{:^8} {:^8} {:^8} {:^8} {:^8} {:^8}'.format(
    '', '', '', '', '',
    )

for (x1, y1), (x2, y2) in [ ((5, 5), (6, 6)),
                            ((-6, -6), (-5, -5)),
                            ((0, 0), (3, 4)), # 3-4-5 truanle
                            ((-1, -1), (2, 3)), # 3-4-5 triangle
                            ]:
    x = x1 - x2
    y = y1 - y2
    h = math.hypot(x, y)
    print '{:8.2f} {:8.2f} {:8.2f} {:8.2f} {:8.2f} {:8.2f}'.format(
        x1, y1, x2, y2, h,
        )
import math

for r in [ 0, 0.5, 1 ]:
    print 'arcsine(%.1f) = %5.2f' % (r, math.asin(r))
    print 'arcsine(%.1f) = %5.2f' % (r, math.acos(r))
    print 'arctangent(%.1f) = %5.2f' % (r, math.atan(r))
    print
import math

print '{:^6} {:^6} {:^6} {:^6} {:^6}'.format(
    'X', 'sinh', 'cosh', 'tanh',
    )
print '{:-^6} {:-^6} {:-^6} {:-^6}'.format( '', '', '', '')

fmt = ' '.join(['{:6.4f}'] * 4)

for i in range(0, 11, 2):
    x = i/10.0
    print fmt.format(x, math.sinh(x), math.cosh(x), math.tanh(x))
import math

print '{:^5} {:7}'.format('x', 'erf(x)')
print '{:-^5} {:-^7}'.format('', '')

for x in [ -3, -2, -1, -0.5, -0.25, 0, 0.25, 0.5, 1, 2, 3 ]:
    print '{:5.2f} {:7.4f}'.format(x, math.erf(x))
import math

print '{:^5} {:7}'.format('x', 'erfc(x)')
print '{:-^5} {:-^7}'.format('', '')

for x in [ -3, -2, -1, -0.5, -0.25, 0, 0.25, 0.5, 1, 2, 3 ]:
    print '{:5.2f} {:7.4f}'.format(x, math.erfc(x))

    この2つの値の精度は、プラットフォームの浮動小数点Cライブラリの制限を受け入れるだけです。
外れ値に対するテスト
        浮動小数点演算で発生する異常値には2種類あります。1 つは INF（無限大）で、浮動小数点値を double で保存したときに、非常に大きな絶対値に対してオーバーフローする場合に発生する異常値です。

import math

print '{:^3} {:6} {:6} {:6} {:6}'.format('e', 'x', 'x**2', 'isinf')
print '{:-^3} {:-^6} {:-^6} {:-^6}'.format('', '', '', '', '')

for e in range(0, 201, 20):
    x = 10.0 ** e
    y = x*x
    print '{:3d} {!s:6} {!s:6} {!s:6} {!s:6}'.format(e, x, y, math.isinf(y),)

    この例では、指数が大きくなってxの2乗をdoubleに格納できなくなり、その値はinfinityとして記録されます。
        しかし、すべての浮動小数点演算のオーバーフローがINF値になるわけではありません。具体的には、浮動小数点値で指数を計算すると、INF の結果が保持されず OverflowError が発生します。

x = 10.0 ** 200

print 'x =', x
print 'x*x =', x*x
try:
    print 'x**2 =', x**2
except OverflowError, err:
    print err

    この違いは、C言語とPythonで使用されるライブラリの実装の違いによるものです。
        無限大を用いた除算演算は未定義です。無限大の値で数値を割ると、NaN（＝数値ではない）になります。

import math

x = (10.0 ** 200) * (10.0 ** 200)
y = x/x

print 'x =', x
print 'isnan(x) =', math.isnan(x)
print 'y = x / x =', x/x
print 'y == nan =', y == float('nan')
print 'isnan(y) =', math.isnan(y)

    NaNはどの値とも等しくないし、それ自身とも等しくないので、NaNをチェックするにはisan()を使う必要があります。
整数に変換する
        mathモジュールには、浮動小数点値を整数に変換するための3つの関数が含まれています。これらの 3 つの関数はそれぞれ異なるアプローチを使用しており、異なる状況に適しています。
        最も単純なのは trunc() で、これは小数点以下を切り捨てて、整数部を構成する有効な数値だけを残します。

import math

HEADINGS = ('i', 'int', 'trunk', 'floor', 'ceil')
print '{:^5} {:^5} {:^5} {:^5} {:^5} {:^5}'.format(*HEADINGS)
print '{:-^5} {:-^5} {:-^5} {:-^5} {:-^5} {:-^5}'.format('', '', '', '', '', '', '',)

fmt = ' '.join(['{:5.1f}'] * 5)

TEST_VALUES = [ -1.5, -0.8, -0.5, -0.2, 0, 0.2, 0.5, 0.8, 1, ]
for i in TEST_VALUES:
    print fmt.format(i, int(i), math.trunc(i), math.floor(i), math.ceil(i))

    trunc() は int への直接変換と同等です。
の他の表現もあります。
        modf() は、浮動小数点数を受け取り、この入力値の小数部と整数部を含むタプルを返します。

import math

for i in range(6):
    print '{}/2 = {}'.format(i, math.modf(i/2.0))

    戻り値の数値はいずれも浮動小数点数です。
        frexp() は浮動小数点数の仮数と指数を返すので、この値をより移植性の高い表現にするために使用できます。

import math

print '{:^7} {:^7} {:^7}'.format('x', 'm', 'e')
print '{:-^7} {:-^7} {:-^7}'.format('', '', '')

for x in [ 0.1, 0.5, 4.0 ]:
    m, e = math.frexp(x)
    print '{:7.2f} {:7.2f} {:7d}'.format(x, m, e)

    frexp() は x = m * 2**e という公式を使い、m と e という値を返します。
        ldexp()はfrexp()の正反対です。

import math

print '{:^7} {:^7} {:^7}'.format('x', 'm', 'e')
print '{:-^7} {:-^7} {:-^7}'.format('', '', '')

for m, e in [ (0.8, -3),
              (0.5, 0),
              (0.5, 3)
              ]:
    x = math.ldexp(m, e)
    print '{:7.2f} {:7d} {:7.2f}'.format(m, e, x)

    frexp()と同じ式で、ldexp()は引数として末尾と指数値を取り、浮動小数点数を返します。
正負の符号
        数値の絶対値とは、プラスとマイナスの符号を除いた主な値のことです。浮動小数点数の絶対値を計算するには、fabs()を使用します。

import math

print math.fabs(-1.1)
print math.fabs(-0.0)
print math.fabs(0.0)
print math.fabs(1.1)

    実は、浮動小数点数の絶対値は、正の値で表されます。
        値の符号を決めるには、たとえば一連の値に同じ符号をつけたり、2つの値を比較したりするには、copysign()を使って正しい値の符号を設定することができる。

import math

HEADINGS = ('f', 's', '< 0', '> 0', '= 0')
print '{:^5} {:^5} {:^5} {:^5} {:^5} {:^5}'.format(*HEADINGS)
print '{:-^5} {:-^5} {:-^5} {:-^5} {:-^5} {:-^5}'.format('', '', '', '', '', '', '',)

for f in [ -1.0,
           0.0,
           1.0,
           float('-inf'),
           float('inf'),
           float('-nan'),
           float('-nan'),
           ]:
    s = int(math.copysign(1, f))
    print '{:5.1f} {:5d} {!s:5} {!s:5} {!s:5} {!s:5}'.format(
        f, s, f < 0, f > 0, f==0,
        )

    NaNや-NaNは他の値と直接比較できないので、copysign()のような追加関数も必要である。
よく使われる計算
        バイナリ浮動小数点メモリで正確な値を表現することは困難な場合があります。正確には表現できない値もありますし、計算を繰り返して処理する回数が多ければ多いほど、表現上の誤差が生じやすくなります。

import math

values = [ 0.1 ] * 10

print 'Input values:', values

print 'sum() : {:.20f}'.format(sum(values))

s = 0.0
for i in values:
    s += i
print 'for-loop : {:.20f}'.format(s)

print 'math.fsum() : {:.20f}'.format(math.fsum(values))

    10個の値の列があり、それぞれが0.1に等しいとすると、この列の和は1.0になることが期待されます。しかし、0.1は浮動小数点値として正確に表現できないので、fsum()を使って計算しない限り、和に誤差が生じます。
        factorial() は、一連のオブジェクトの並べ換えや組み合わせの数を計算するためによく使われます。正の整数 n の階乗 (n! と表記) は、再帰的に (n-1)! *と再帰的に定義され、0!==1で再帰を停止する。

import math

for i in [ 0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.1 ]:
    try:
        print '{:2.0f} {:6.0f}'.format(i, math.factorial(i))
    except ValueError, err:
        print 'Error computing factorial(%s):' % i, err

    factorial() は整数値しか扱うことができませんが、値を失うことなく整数に変換できる限りは float 引数を受け付けます。
        gamma() は factorial() と似ていますが、実数を扱うことができ、値が1つ下にシフトされます (gamma は (n-1) に等しい!) .

import math

for i in [ 0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 ]:
    try:
        print '{:2.1f} {:6.2f}'.format(i, math.gamma(i))
    except ValueError, err:
        print 'Error computing gamma(%s):' % i, err

    0だとスタート値がマイナスになるので、これは許されない。
        lgamma() は、入力値に対してガンマを求めることによって得られる絶対値の自然対数を返します。

import math

for i in [ 0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 ]:
    try:
        print '{:2.1f} {:.20f} {:.20f}'.format(i, math.lgamma(i), math.log(math.gamma(i)))
    except ValueError, err:
        print 'Error computing lgamma(%s):' % i, err

    lgamma()を使用すると、gamma()の結果だけを使用するよりも正確に対数を計算することができます。
        モジュロ演算子 (%) は除算式の余りを計算します (例: 5%2=1)。 Python 言語の組み込み演算子は整数ではうまく動作しますが、他の多くの浮動小数点演算と同様に、中間計算が表現の問題やさらなるデータ損失を引き起こすことがあります。 fmod() は浮動小数点値に対してより正確な実装を提供することができます。

import math

print '{:^4} {:^4} {:^5} {:^5}'.format('x', 'y', '%', 'fmod')
print '---- ---- ----- -----'

for x, y in [ (5, 2),
              (5, -2),
              (-5, 2),
              ]:
    print '{:4.1f} {:4.1f} {:5.2f} {:5.2f}'.format(
        x,
        y,
        x % y,
        math.fmod(x, y),
        )

    また、混乱を招きやすい点として、fmod()がモードを計算する際に使用するアルゴリズムも、%で使用するアルゴリズムと異なるため、結果の符号が異なることが挙げられます。
指数と対数
        Pythonには組み込みのべき乗演算子(**)がありますが、呼び出し可能な関数を別の関数の引数として取る必要がある場合、pow()を使用する必要があるかもしれません。

import math

for x, y in [
    # Typical uses
    (2, 3),
    (2.1, 3.2),

    # Always 1
    (1.0, 5),
    (2.0, 0),

    # Not-a-number
    (2, float('nan')),

    # Roots
    (9.0, 0.5),
    (27.0, 1.0/3),
    ]:
    print '{:5.1f} ** {:5.3f} = {:6.3f}'.format(
        x,
        y,
        math.pow(x, y),
        )

    1の累乗は常に1.0を返し、同様に、指数が0.0の値は常に1.0を返します。ほとんどの操作は、"not a number" 値のnanを返します。指数が1より小さい場合、pow()はルートを計算します。
        平方根（1/2の指数）はよく使われるので、平方根を計算する関数が別に用意されています。

import math

print math.sqrt(9.0)
print math.sqrt(3)
try:
    print math.sqrt(-1)
except ValueError, err:
    print 'Cannot compute sqrt(-1):', err

    負の数の平方根を計算するには、数学の範囲外である複素数を使用する必要があります。負の値の平方根を計算しようとすると、ValueError が発生します。
        log関数は、x = b ** yという条件を満たすyを求めます。デフォルトでは、log()は（底eの）自然対数を計算します。もし第2引数が与えられると、この引数の値が底として使われます。

import math

print math.log(8)
print math.log(8, 2)
print math.log(0.5, 2)

    x が 1 より小さいとき、ロギングは負の結果を生成する。
        log()には2つのバリエーションがあります。浮動小数点表現と丸め誤差が与えられると、log(x, b) は限られた精度（特に特定の基数について）の計算値を生成します。 log10() は log(x, 10) の計算を行いますが、log() よりも正確なアルゴリズムを使用します。

import math

print '{:2} {:^12} {:^10} {:^20} {:8}'.format(
    'i', 'x', 'accurate', 'inaccurate', 'mismatch',
    )
print '{:-^2} {:-^12} {:-^10} {:-^20} {:-^8}'.format(
    '', '', '', '', '',
    )

for i in range(0, 10):
    x = math.pow(10, i)
    accurate = math.log10(x)
    inaccurate = math.log(x, 10)
    match = '' if int(inaccurate) == i else '*'
    print '{:2d} {:12.1f} {:10.8f} {:20.18f} {:^5}'.format(
        i, x, accurate, inaccurate, match,
        )

    出力の末尾に*の付いた行は、不正確な値を強調するものです。
        loglp() はニュートン・メルカトル数列（1+x の自然対数）を計算します。

import math

x = 0.00000000000000000000000000001
print 'x :', x
print '1 + x :', 1 + x
print 'log(1 + x):', math.log(1 + x)
print 'loglp(x):', math.log1p(x)

    xが0に非常に近い場合、loglp()は最初の加算で生じる丸め誤差を補正するアルゴリズムを使用しているので、より正確です。
        exp() は、指数関数 (e**x) を計算します。

import math

x = 2

fmt = '%.20f'
print fmt % (math.e ** 2)
print fmt % math.pow(math.e, 2)
print fmt % math.exp(2)

<スパン     他の特殊ケース関数と同様に、exp()はその汎用的な同等品であるmath.pow(math.e, x)よりも正確な結果を生成するアルゴリズムを使用します。
        expml()はloglp()の逆で、e**x - 1を計算します。

import math

x = 0.00000000000000000000000000001
print x
print math.exp(x) - 1
print math.expm1(x)

    loglp()と同様、xの値が小さい場合、引き算だけでは精度が落ちます。
角度
        角度を論じるときには度を使うことが多いが、科学や数学で角度を表す標準的な単位はラジアンである。ラジアンとは、円の中心で交差する2本の直線の端点が円の円周上に位置し、端点が1ラジアン離れていることでできる角度のことで、円周上に位置する2本の直線の端点が1ラジアン離れていることで、円周上に位置する2本の直線の端点が1ラジアン離れていることである。
        円の円周は2πrとして計算されるので、ラジアンとπ（三角関数の計算でよく出てくる値）には関係があるのです。この関係から、ラジアンを使うと計算式がコンパクトになるため、三角法でも微積分法でもラジアンが使われるようになった。
        度数をラジアンに変換するには、radians()を使用します。

import math

print '{:^7} {:^7} {:^7} {:^7}'.format('Degrees', 'Radians', 'Expected')
print '{:^7} {:^7} {:^7}'.format('', '', '')

for deg, expected in [ ( 0, 0),
                       ( 30, math.pi/6),
                       ( 45, math.pi/4),
                       ( 60, math.pi/3),
                       ( 90, math.pi/2),
                       (180, math.pi),
                       (270, 3/2.0 * math.pi),
                       (360, 2 * math.pi),
                       ]:
    print '{:7d} {:7.2f} {:7.2f}'.format(deg,
                                           math.radians(deg),
                                           expected,
                                           )

   変換式は、rad = deg * π / 180です。
        ラジアンから度に変換するには、度()を使用します。

import math

print '{:^8} {:^8} {:^8}'.format('Radians', 'Degrees', 'Expected')
print '{:-^8} {:-^8} {:-^8}'.format('', '', '')

for rad, expected in [ (0, 0),
                       (math.pi/6, 30),
                       (math.pi/4, 45),
                       (math.pi/3, 60),
                       (math.pi/2, 90),
                       (math.pi, 180),
                       (3 * math.pi / 2, 270),
                       (2 * math.pi, 360),
                       ]:
    print '{:8.2f} {:8.2f} {:8.2f}'.format(rad,
                                           math.degrees(rad),
                                           expected,
                                           )

    具体的な変換式は、deg = rad * 180 / πです。
三角関数
        三角関数は、三角形の角と辺の長さを関係付ける関数である。三角関数は、高調波や円運動などの周期的な性質を持つ数式によく登場し、また、角度を扱うときによく使われる。標準ライブラリのすべての三角関数の角度の引数はラジアン単位で表現されます。
        直角三角形の角度があるとき、その正弦は対辺の長さと斜辺の長さの比（sinA = 対辺/斜辺）です。余弦は、隣接する辺の長さと斜辺の長さの比である (cosA = adjacent/hypotenuse)。接線は、反対側の辺と隣接する辺の比である（tanA = 反対側/隣接側）。

import math

print 'Degrees Radians Sine Cosine Tangent'
print '------- ------- ------- -------- -------'

fmt = ' '.join(['%7.2f'] * 5)

for deg in range(0, 361, 30):
    rad = math.radians(deg)
    if deg in (90, 270):
        t = float('inf')
    else:
        t = math.tan(rad)
    print fmt % (deg, rad, math.sin(rad), math.cos(rad), t)

    また、正接はこの角度の正弦と余弦の比として定義でき、ラジアンπ / 2と3π / 2の余弦は0であるから、対応する正接は無限大となる。
        点 (x, y) があるとき、点 [(0, 0), (x, 0), (x, y)] が作る三角形の斜辺の長さは (x**2 + y**2) ** 1/2 であり、これは hypot() を使って計算することができる。

import math

print '{:^7} {:^7} {:^10}'.format('x', 'y', 'Hypotenuse')
print '{:-^7} {:-^7} {:-^10}'.format('', '', '')

for x, y in [ # simple points
                (1, 1),
                (-1, -1),
                (math.sqrt(2), math.sqrt(2)),
                (3, 4), # 3-4-5 triangle
                # on the circle
                (math.sqrt(2)/2, math.sqrt(2)/2), # pi/4 rads
                (0.5, math.sqrt(3)/2), # pi/3 rads
                ]:
    h = math.hypot(x, y)
    print '{:7.2f} {:7.2f} {:7.2f}'.format(x, y, h)

    円周上の点では、常に斜辺==1 を求める。
        また、この関数は2点間の距離を見るのにも使えます。

import math

print '{:^8} {:^8} {:^8} {:^8} {:^8} {:^8}'.format(
    'X1', 'Y1', 'X2', 'Y2', 'Distance',
    )
print '{:^8} {:^8} {:^8} {:^8} {:^8} {:^8}'.format(
    '', '', '', '', '',
    )

for (x1, y1), (x2, y2) in [ ((5, 5), (6, 6)),
                            ((-6, -6), (-5, -5)),
                            ((0, 0), (3, 4)), # 3-4-5 truanle
                            ((-1, -1), (2, 3)), # 3-4-5 triangle
                            ]:
    x = x1 - x2
    y = y1 - y2
    h = math.hypot(x, y)
    print '{:8.2f} {:8.2f} {:8.2f} {:8.2f} {:8.2f} {:8.2f}'.format(
        x1, y1, x2, y2, h,
        )

    x 値の差と y 値の差を用いて端点を原点に移動させ、その結果を hypot() に渡します。
        math は逆三角関数も定義しています。

import math

for r in [ 0, 0.5, 1 ]:
    print 'arcsine(%.1f) = %5.2f' % (r, math.asin(r))
    print 'arcsine(%.1f) = %5.2f' % (r, math.acos(r))
    print 'arctangent(%.1f) = %5.2f' % (r, math.atan(r))
    print

    1.57はπ / 2、つまり90度にほぼ等しく、この角度は正弦が1、余弦が0となる。
ハイパーボリック関数
        双曲線関数は線形微分方程式によく登場し、電磁場、流体力学、特殊相対性理論などの高度な物理・数学の問題を扱うときによく使われる。

import math

print '{:^6} {:^6} {:^6} {:^6} {:^6}'.format(
    'X', 'sinh', 'cosh', 'tanh',
    )
print '{:-^6} {:-^6} {:-^6} {:-^6}'.format( '', '', '', '')

fmt = ' '.join(['{:6.4f}'] * 4)

for i in range(0, 11, 2):
    x = i/10.0
    print fmt.format(x, math.sinh(x), math.cosh(x), math.tanh(x))

    コサイン関数とサイン関数は円を、ハイパーボリックコサイン関数とハイパーボリックサイン関数は双曲線の半分を形成しています。
        逆ハイパーボリック関数 acosh(), asinh(), atanh() も提供されています。
特殊機能
        統計学では、ガウス誤差関数（GEF）がよく使われます。

import math

print '{:^5} {:7}'.format('x', 'erf(x)')
print '{:-^5} {:-^7}'.format('', '')

for x in [ -3, -2, -1, -0.5, -0.25, 0, 0.25, 0.5, 1, 2, 3 ]:
    print '{:5.2f} {:7.4f}'.format(x, math.erf(x))

    誤差関数の場合、erf(-x) == -erf(x) となります。
        誤差関数の補集合は1-erf(x)です。

import math

print '{:^5} {:7}'.format('x', 'erfc(x)')
print '{:-^5} {:-^7}'.format('', '')

for x in [ -3, -2, -1, -0.5, -0.25, 0, 0.25, 0.5, 1, 2, 3 ]:
    print '{:5.2f} {:7.4f}'.format(x, math.erfc(x))

        xの値が小さい場合、erfc()の実装は1からの引き算の際に発生しうる精度誤差を回避することができます。