Python:实现lorenz transformation 洛伦兹变换算法(附完整源码)

from
__future__
import
annotations




from
math
import
sqrt




import
numpy
as
np
# type: ignore


from
sympy
import
symbols
# type: ignore




# Coefficient


# Speed of light (m/s)


c
=
299792458




# Symbols


ct,
x,
y,
z
=
symbols(
"ct x y z")


ct_p,
x_p,
y_p,
z_p
=
symbols(
"ct' x' y' z'")






# Vehicle's speed divided by speed of light (no units)


def
beta(
velocity:
float)
-
>
float:


"""


 >>> beta(c)


 1.0




 >>> beta(199792458)


 0.666435904801848




 >>> beta(1e5)


 0.00033356409519815205




 >>> beta(0.2)


 Traceback (most recent call last):


 ...


 ValueError: Speed must be greater than 1!


 """


if
velocity
>
c:


raise
ValueError(
"Speed must not exceed Light Speed 299,792,458 [m/s]!")




# Usually the speed u should be much higher than 1 (c order of magnitude)


elif
velocity
<
1:


raise
ValueError(
"Speed must be greater than 1!")


return
velocity
/
c






def
gamma(
velocity:
float)
-
>
float:




return
1
/ (
sqrt(
1
-
beta(
velocity)
*
*
2))






def
transformation_matrix(
velocity:
float)
-
>
np.
array:




 
return
np.
array(

 [

 [
gamma(
velocity),
-
gamma(
velocity)
*
beta(
velocity),
0,
0],

 [
-
gamma(
velocity)
*
beta(
velocity),
gamma(
velocity),
0,
0],

 [
0,
0,
1,
0],

 [
0,
0,
0,
1],

 ]

 )






def
transform(


velocity:
float,
event:
np.
array
=
np.
zeros(
4),
symbolic:
bool
=
True

)
-
>
np.
array:




# Ensure event is not a vector of zeros


if
not
symbolic:




# x0 is ct (speed of ligt * time)


event[
0]
=
event[
0]
*
c


else:




# Symbolic four vector


event
=
np.
array([
ct,
x,
y,
z])




return
transformation_matrix(
velocity).
dot(
event)






if
__name__
==
"__main__":


import
doctest




doctest.
testmod()




# Example of symbolic vector:


four_vector
=
transform(
29979245)


print(
"Example of four vector: ")


print(
f"ct' = {
four_vector[
0]}
")


print(
f"x' = {
four_vector[
1]}
")


print(
f"y' = {
four_vector[
2]}
")


print(
f"z' = {
four_vector[
3]}
")




# Substitute symbols with numerical values:


values
=
np.
array([
1,
1,
1,
1])


sub_dict
= {
ct:
c
*
values[
0],
x:
values[
1],
y:
values[
2],
z:
values[
3]}


numerical_vector
= [
four_vector[
i].
subs(
sub_dict)
for
i
in
range(
0,
4)]




print(
f"\n{
numerical_vector}
")


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.