4000. 12. PYTHON Code for coupling constants with 200 decimal digits precision output.

This PYTHON Code computes coupling constants from K_-39.0 to K_+18.5

1    import mpmath as mp

2   

3    # Set desired precision (100 or 200 decimal digits)

4    mp.mp.dps = 200  # Change to 200 if you need 200 decimal digits of precision

5   

6    # Define Constants with high precision

7    C_0 = mp.mpf(

8        "0.9869763503843571923955121936342636366933158873206820384157142768900062650686530211391494897733630580622746241867200156070025829718439936494135821020466414603141110853110509328310852506004581818658909"

9    )  # or directly from mathematical definitions if available

10   PI = mp.pi

11   E = mp.e

12   C_87 = PI / E  # PI / E

13   C_8 = PI  # PI

14  

15   # Output file path (adjust as needed for your OS/system)

16   output_filename = "ALFA_THETA_GENERAL_ARBITRARY_PRECISION.txt"

17  

18   with open(output_filename, "w", encoding="utf-8") as f:

19  

20       # Loop DO I = -100, 38

21       for i in range(-78, 16):  # range in Python is exclusive at the upper bound

22  

23           X = mp.mpf(i) / mp.mpf(2)

24  

25           # ------------------------------------------------------------------

26           # PART A OF EXPM = (A/B)^C

27           # ------------------------------------------------------------------

28           A = mp.mpc(C_0) ** ((X - mp.mpf(8)) / mp.mpf(8))

29  

30           # ------------------------------------------------------------------

31           # PART B OF EXPM = (A/B)^C

32           # ------------------------------------------------------------------

33           B_1 = C_0 * (C_87**X)

34           B_2 = (X - mp.mpf(8)) / (X**2 - mp.mpf(16) * X + mp.mpf(80))

35           B_3 = (mp.mpf(11) * X - mp.mpf(88)) / mp.mpf(24)

36  

37           # B = ((B_1 * B_2) ** B_3)

38           B = mp.mpc(B_1 * B_2) ** mp.mpc(B_3)

39  

40           # ------------------------------------------------------------------

41           # PART C OF THE EQUATION (A/B) ** C

42           # ------------------------------------------------------------------

43           C_1 = C_0 * (C_87 ** mp.mpc(X))

44           C_2 = mp.mpc((X - mp.mpf(8)) / mp.mpf(24))

45           C = C_1 * C_2

46  

47           # ------------------------------------------------------------------

48           # EXPM = (A/B)**C

49           # ------------------------------------------------------------------

50           EXPM = (A / B) ** C

51  

52           # ------------------------------------------------------------------

53           # COMPUTE ALFA_MINUS_HALF_1, 2, 3

54           # ------------------------------------------------------------------

55           ALFA_MINUS_HALF_1 = mp.mpc(C_0) * (C_87 ** (mp.mpc(X) + EXPM))

56           ALFA_MINUS_HALF_2 = (X - mp.mpf(8)) / (

57               (X * X) - mp.mpf(16) * X + mp.mpf(80)

58           )

59           ALFA_MINUS_HALF_3 = (mp.mpf(9) * X - mp.mpf(8)) / (mp.mpf(8) * EXPM)

60  

61           # ALFA_MINUS_HALF = (ALFA_MINUS_HALF_1 * ALFA_MINUS_HALF_2) ** ALFA_MINUS_HALF_3

62           ALFA_MINUS_HALF = (ALFA_MINUS_HALF_1 * ALFA_MINUS_HALF_2) ** mp.mpc(

63               ALFA_MINUS_HALF_3

64           )

65  

66           # ALFA_SQUARE = (ALFA_MINUS_HALF) ** 2

67           ALFA_SQUARE = ALFA_MINUS_HALF ** mp.mpf(2)

68  

69           # FINAL ALFA = 1 / ALFA_SQUARE

70           ALFA_FINAL = mp.mpf(1) / ALFA_SQUARE

71  

72           # ------------------------------------------------------------------

73           # POLAR AND COMPONENT VALUES

74           # ------------------------------------------------------------------

75           REAL_PART = mp.re(ALFA_FINAL)

76           IMAG_PART = mp.im(ALFA_FINAL)

77           ABSOL_VALUE = abs(ALFA_FINAL)

78  

79           # Angle Theta in radians: atan2(imag, real) or arg(ALFA_FINAL)

80           THETA = mp.atan2(IMAG_PART, REAL_PART)

81  

82           # Angle Theta in degrees

83           THETA_DEG = (THETA * mp.mpf(180)) / C_8

84  

85           # ------------------------------------------------------------------

86           # WRITE TO FILE (Matching Fortran output structure)

87           # ------------------------------------------------------------------

88           f.write("LOOP VARIABLE X......................................\n")

89           f.write(f" {mp.nstr(X, mp.mp.dps)}\n")

90           f.write("_____________________________________________________\n")

91  

92           f.write("PART A...............................................\n")

93           f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(A, mp.mp.dps)}\n")

94           f.write("_____________________________________________________\n")

95  

96           f.write("PART B...............................................\n")

97           f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(B_1, mp.mp.dps)}\n")

98           f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(B_2, mp.mp.dps)}\n")

99           f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(B_3, mp.mp.dps)}\n")

100          f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(B, mp.mp.dps)}\n")

101          f.write("_____________________________________________________\n")

102 

103          f.write("PART C...............................................\n")

104          f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(C_1, mp.mp.dps)}\n")

105          f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(C_2, mp.mp.dps)}\n")

106          f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(C, mp.mp.dps)}\n")

107          f.write("_____________________________________________________\n")

108 

109          f.write("EXPONENT MAIN = (A/B)**C.............................\n")

110          f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(EXPM, mp.mp.dps)}\n")

111          f.write("_____________________________________________________\n")

112 

113          f.write("ALFA ^ ( -1/2 ) PART.................................\n")

114          f.write(

115              f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(ALFA_MINUS_HALF_1, mp.mp.dps)}\n"

116          )

117          f.write(

118              f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(ALFA_MINUS_HALF_2, mp.mp.dps)}\n"

119          )

120          f.write(

121              f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(ALFA_MINUS_HALF_3, mp.mp.dps)}\n"

122          )

123          f.write(

124              f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(ALFA_MINUS_HALF, mp.mp.dps)}\n"

125          )

126          f.write("ALFA SQUARE_________________________________________\n")

127          f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(ALFA_SQUARE, mp.mp.dps)}\n")

128          f.write("_____________________________________________________\n")

129 

130          f.write("ALPHA FINAL = RECIPROCAL OF ALFA TO POWER MINUS 1____\n")

131          f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(ALFA_FINAL, mp.mp.dps)}\n")

132          f.write("_____________________________________________________\n")

133 

134          f.write("REAL PART OF ALPHA...................................\n")

135          f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(REAL_PART, mp.mp.dps)}\n")

136 

137          f.write("IMAGINARY PART OF ALPHA..............................\n")

138          f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(IMAG_PART, mp.mp.dps)}\n")

139          f.write("_____________________________________________________\n")

140 

141          f.write("ABSOLUTE VALUE = MODULUS OF ALFA.....................\n")

142          f.write(f" {mp.nstr(X, mp.mp.dps)}  {mp.nstr(ABSOL_VALUE, mp.mp.dps)}\n")

143 

144          f.write("ANGLE THETA OF POLAR FORM............................\n")

145          f.write(f" {mp.nstr(THETA, mp.mp.dps)}\n")

146 

147          f.write("ANGLE THETA IN DEGREES...............................\n")

148          f.write(f" {mp.nstr(THETA_DEG, mp.mp.dps)}\n")

149          f.write("_____________________________________________________\n")

150 

151  print(

152      f"Calculations complete. Output saved to {output_filename} with precision = {mp.mp.dps} decimal places."

153  )

154