Python 數學運算性能測試

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

# version 1131002
import timeit
import math
import random
import pandas as pd

# calculate U(0, 1) pseudo-random number by Linear Congruential Generator (LCG)
class LCG:
    def __init__(self, seed):
        if not isinstance(seed, (int, float)):
            raise TypeError('seed must be a number (int or float).')
        self.state = seed

    def random(self):
        self.state = (1103515245 * self.state + 12345) % 2147483648
        return self.state / 2147483648
    
    def randint(self, low, high):
        return low + int(self.random() * (high - low))


# calculate U(0, 1) pseudo-random number by Learmonth-Lewis Generator (LLG)
class LLG:
    def __init__(self, seed):
        if not isinstance(seed, (int, float)):
            raise TypeError('seed must be a number (int or float).')
        self.state = seed
        
    def random(self):
        self.state = (16807 * self.state) % 2147483647
        return self.state / 2147483647
    
    def randint(self, low, high):
        return low + int(self.random() * (high - low + 1))

# function
def test_add(): return a + b
def test_sub(): return a - b
def test_mul(): return a * b
def test_div(): return a / b
def test_mod(): return a % b
def test_pow(): return math.pow(a, b)
def test_abs(): return abs(a)
def test_log(): return math.log(a)
def test_log10(): return math.log10(a)
def test_exp(): return math.exp(a)
def test_sqrt(): return math.sqrt(a)
def test_square(): return a ** 2
def test_sin(): return math.sin(a)
def test_cos(): return math.cos(a)
def test_tan(): return math.tan(a)
def test_asin(): return math.asin(a / b)
def test_acos(): return math.acos(a / b)
def test_atan(): return math.atan(a)
def test_sinh(): return math.sinh(a)
def test_cosh(): return math.cosh(a)
def test_tanh(): return math.tanh(a)
def test_asinh(): return math.asinh(a)
def test_acosh(): return math.acosh(b)
def test_atanh(): return math.atanh(a / b)
def test_uniform(): return random.uniform(0, 1)
def test_normal(): return random.gauss(0, 1)
def test_randint(): return random.randint(0, 100)
def test_exponential(): return random.expovariate(1)
def test_gamma(): return random.gammavariate(2, 2)
def test_beta(): return random.betavariate(2, 5)
def test_triangular(): return random.triangular(0, 10, 5)
def test_mt(): return random.random()
def test_lcg(): return lcg.random()
def test_llg(): return llg.random()

a = 1.234
b = 5.678
lcg = LCG(seed = 42)
llg = LLG(seed = 42)
times = 100000000

operations = [
    ("Addition (+)", test_add),
    ("Subtraction (-)", test_sub),
    ("Multiplication (*)", test_mul),
    ("Division (/)", test_div),
    ("Modulus (%)", test_mod),
    ("Power (pow)", test_pow),
    ("Absolute (abs)", test_abs),
    ("Logarithm (log)", test_log),
    ("Logarithm Base 10 (log10)", test_log10),
    ("Exponential (exp)", test_exp),
    ("Square Root (sqrt)", test_sqrt),
    ("Square (**)", test_square),
    ("Sine (sin)", test_sin),
    ("Cosine (cos)", test_cos),
    ("Tangent (tan)", test_tan),
    ("Arcsine (asin)", test_asin),
    ("Arccosine (acos)", test_acos),
    ("Arctangent (atan)", test_atan),
    ("Hyperbolic Sine (sinh)", test_sinh),
    ("Hyperbolic Cosine (cosh)", test_cosh),
    ("Hyperbolic Tangent (tanh)", test_tanh),
    ("Inverse Hyperbolic Sine (asinh)", test_asinh),
    ("Inverse Hyperbolic Cosine (acosh)", test_acosh),
    ("Inverse Hyperbolic Tangent (atanh)", test_atanh),
    ("Random Uniform", test_uniform),
    ("Random Normal", test_normal),
    ("Random Integer", test_randint),
    ("Exponential Distribution", test_exponential),
    ("Gamma Distribution", test_gamma),
    ("Beta Distribution", test_beta),
    ("Triangular Distribution", test_triangular),
    ("Mersenne Twister (MT)", test_mt),
    ("Linear Congruential Generator (LCG)", test_lcg),
    ("Linear Lagged Generator (LLG)", test_llg),
]

# output
results = []
for name, func in operations:
    time = timeit.timeit(func, number = times)
    results.append((name, time))
    print(f"{name}: {time:.6f} seconds")

min_time = min([time for name, time in results])
output_data = [(name, time, time / min_time) for name, time in results]
df = pd.DataFrame(output_data, columns = ["Operation", "Time (seconds)", "Relative Time (min = 1)"])
df.to_csv("operation_timing_results.csv", index = False)

print("result:\n", df)