質量変化による近点移動

近点移動は、衝突により、天体の質量が変化したために発生します。
多分、この理論は、まだ誰も考えていないはずです。
(静的エネルギー、動的エネルギー)で近点移動を考えていないからです。

とりあえず、
土星と月の2度の衝突について、プログラミングしてみた。
コメントがまだ全部に入れてないけれど、
だいたいの雰囲気は伝わるはずです。

プログラム(python)

import numpy as nm

#=============================================#

# CLASS : uniVerse

#         宇宙クラス

#=============================================#

class uNiverse:

    c = 1.0792528488E+9   #光速(km/h)

    U = 7.4242576375E-31  #質量・光速時基準軌道 変換定数 (km/kg)

    CsS=1296000           #円周の秒数(秒)

    CyT=8760              #年間時間(時間)

    def Sa(self,M,m,a):

        EA = self.EA(M,m)

        Sa = EA/a

        return Sa

    def EA(self,M,m):

        EA = self.Em(m) * self.ac(M,m)

        return EA

    def Em(self,m):

        Em = m * self.c**2

        return Em

    def ac(self,M,m):

        ac = self.U * (M + m)

        return ac

    def va(self,Sa,m):

        va = nm.sqrt(Sa/m)

        return va

#=============================================#

# CLASS : pLanet

#         惑星クラス

#=============================================#

class pLanet:

    def A(self,m,v):

        self.A = m * v**2

        return self.A

    def prt(self):

        print(f”NAME    ={self.name:10S}”)

        print(f”mass    ={self.m:.5e}”)

        print(f”VELOCITY={self.v:.5e}”)

        print(f”D.ENERGY={self.A:.5e}”)

#=============================================#

# CLASS : pLmove

#         惑星移動クラス

#=============================================#

class pLmove(uNiverse,pLanet):

    def ax(self,Sa,EA,Ax):

        self.a = EA/(Sa – Ax)

        return self.a

    def SRP(self,a,v):

        self.SRP = 2 * nm.pi * a / v

        return self.SRP

#=============================================#

# CLASS : iMpact

#         衝突クラス

#=============================================#

class iMpact(pLmove):

#

# pMove:衝突後の変化した分の質量

#    <PRM> m:衝突前の天体の質量(kg)

#          a:基準軌道半径(km)

#          v:速度(km/h)

#          margin:年間近点移動角度(秒)

#    <RTN> 

#       SRP:公転周期(Sidereal Rotation Period)#self    

#       Ny:1年の公転回数 #self

#       deG:1公転での近点移動角度 #self

#       ΔT:1公転での近点移動時間(h) #self

#       Tf:1公転での近点移動を含めた時間(h) #self

#       mf:衝突後の天体質量(kg) #self

#       Δm:衝突によって変化した分の質量(kg) #self+RTN

    def iMpact(self,m,a,v,margin):

        SRP = self.SRP(a,v)

        Ny  = self.Ny(SRP)

        deg = self.deG(margin,Ny)

        ΔT  = self.ΔT(deg,SRP)

        Tf  = self.Tf(SRP,ΔT)

        mf  = self.mf(m,Tf,SRP)

        Δm  = self.Δm(mf,m)

        return Δm,Tf

#

# Ny:1年の公転回数

#    <PRM> SRP:公転周期 時間(h)

#    <RTN> Ny:1年の公転回数

    def Ny(self,SRP):

        Ny=self.CyT / SRP

        return Ny

#

# deG:1公転での近点移動角度

#    <PRM> margin:近点移動年間移動角度(秒)

#    <RTN> deG:1公転での近点移動角度(秒)

    def deG(self,margin,Ny):

        deG=margin/Ny

        return deG

#

# ΔT:1公転での近点移動時間(h)

#    <PRM> deG:1公転での近点移動角度(秒)

#    <RTN> ΔT:1公転での近点移動時間(h)

    def ΔT(self,deg,SRP):

        ΔT = deg / self.CsS * SRP

        return ΔT

#

# Tf:1公転での近点移動を含めた時間(h)

#    <PRM> SRP:公転周期 時間(h)

#    <RTN> Tf:1公転での近点移動を含めた時間(h)

    def Tf(self,SRP,ΔT):

        Tf = SRP+ΔT

        return Tf

#

# mf:衝突後の天体質量(kg)

#    <PRM> m :衝突前の天体の質量(kg)

#          Tf:1公転での近点移動を含めた時間(h)

#         SRP:公転周期 時間(h)

#    <RTN> mf:衝突後の天体質量(kg)

    def mf(self,m,Tf,SRP):

        mf=m*(Tf/SRP)**2

        return mf

#

# Δm:衝突によって変化した分の質量(kg)

#    <PRM> m :衝突前の天体の質量(kg)

#          mf:衝突後の天体質量(kg)

#    <RTN> Δm:衝突によって変化した分の質量(kg)

    def Δm(self,mf,m):

        Δm = mf – m

        return Δm

#

# iE:衝突エネルギー(je=kg*(km/h)2)

#    <PRM> Sai:衝突前基準軌道の静的エネルギー(je)

#          Sa :衝突後基準軌道の静的エネルギー(je)

#    <RTN> iE:衝突エネルギー(je)

    def iE(self,Sai,Sa):

        return Sai-Sa

#

# iA:衝突位置の動的エネルギー(je=kg*(km/h)2)

#    <PRM> Sai:衝突前基準軌道の静的エネルギー(je)

#          iE :衝突後基準軌道の静的エネルギー(je)

#    <RTN> iA:衝突エネルギー(je)

    def iA(self,Sai,iE):

        return Sai+iE        

class SUN(pLmove):

    def __init__(self):

        self.name=”SUN”

        self.m=1.9891e30

class EARTH(pLmove):

    def __init__(self):

        self.name=”EARTH”

        self.m = 5.97219e24

        self.a = 147077401

        self.ρ = 5.51e12 #密度

        self.margin = 11.45 #秒

class MOON(pLmove):

    def __init__(self):

        self.name=”EARTH-MOON”

        self.m = 7.347673e22

        self.a = 356400

        self.ρ = 3.344 #密度

        self.margin = 360*3600/8.85 #秒

#        self.margin = 0

class SATURN(pLmove):

    def __init__(self):

        self.name=”SATURN”

        self.m = 5.68319e26

        self.a = 1349823615

        self.ρ = 0.687e12 #密度

        self.margin = 162.9 #秒

#

# FUNCTION

#

def prBase():

    print(f”<===== {pln.name:10s} IMFORMATION   =====>”)

    print(” “)

    print(f”Mass     ={pln.m:.5e}kg”)    

    print(f”a        ={pln.a:.5e}km”)    

    print(f”ρ        ={pln.ρ:.5e}kg/km3″)    

    print(f”margin   ={pln.margin:.5e}秒”)    

    print(” “)

    return

def prImpact():

    return

def clImpact():

    m   = pln.m

    a   = pln.a

    margin = pln.margin

    Sa  = pln.Sa(M,m,a)

    va  = pln.va(Sa,m)

    v   = va

    ai  = pln.ax(Sa,pln.EA(M,m),Ai)

    Sai = pln.Sa(M,m,ai)

    vi  = pln.va(Sai,m)

    SRP = pln.SRP(ai,vi)

    (Δm,Tf)  = imp.iMpact(m,ai,vi,margin)

    iE  = imp.iE(Sa,Sai)

    print(“< IMPACT IMFORMATION >”)

    print(” “)

    print(f”Sa = {Sa:.5e}je”)

    print(f”Ai = {Ai:.5e}je”)

    print(f”ai = {ai:.5e}km”)

    print(f”vi = {vi:.5e}km/h”)

    print(f”SRP= {SRP/(365*24):.5e}year ({SRP:.5e}hour)”)

    print(f”Tf = {Tf:.5e}hour”)

    print(f”Δm = {Δm:.5e}kg”)

    print(f”mx = {m+Δm:.5e}kg”)

    print(f”iE = {iE:.5e}je”)

    print(” “)

    return

#

# MAIN ROUTINE

#

#

#—– SUN —–

#

sun = SUN()

M = sun.m

#

#—– SATURN —–

#

imp = iMpact()

pln = SATURN()

prBase()

Ai  = 3.9018993407E+34

clImpact()

#

#—– EARTH – MOON 1 —–

#

ert = EARTH()

M   = ert.m

imp = iMpact()

pln = MOON()

pln.a = 356400

prBase()

Ai  = 1.2553914256E+28

clImpact()

#

#—– EARTH – MOON 2 —–

#

ert = EARTH()

M   = ert.m

imp = iMpact()

pln = MOON()

pln.a = 363400

pln.margin = 0

prBase()

Ai  = 5.7748974729E+28

clImpact()

【実行結果】

<===== SATURN     IMFORMATION   =====>

Mass     =5.68319e+26kg

a        =1.34982e+09km

ρ        =6.87000e+11kg/km3

margin   =1.62900e+02秒

< IMPACT IMFORMATION >

Sa = 7.24428e+35je

Ai = 3.90190e+34je

ai = 1.42667e+09km

vi = 3.47279e+04km/h

SRP= 2.94659e+01year (2.58121e+05hour)

Tf = 2.59077e+05hour

Δm = 4.21756e+24kg

mx = 5.72537e+26kg

iE = 3.90190e+34je

<===== EARTH-MOON IMFORMATION   =====>

Mass     =7.34767e+22kg

a        =3.56400e+05km

ρ        =3.34400e+00kg/km3

margin   =1.46441e+05秒

< IMPACT IMFORMATION >

Sa = 1.07784e+30je

Ai = 1.25539e+28je

ai = 3.60600e+05km

vi = 3.80767e+03km/h

SRP= 6.79270e-02year (5.95041e+02hour)

Tf = 5.99608e+02hour

Δm = 1.13225e+21kg

mx = 7.46090e+22kg

iE = 1.25539e+28je



土星の場合
Δm = 4.21756e+24kg 質量が増えて
近点移動 1.62900e+02秒 がおこります。

月の1回目の衝突の場合
Δm = 1.13225e+21kg 質量が増えて
近点移動 1.46441e+05秒 がおこります。

が計算結果からわかります。
月の2回目の衝突の場合は、みなさんで計算してみてください。

Pythonというプログラム言語

20代から考えると

IBM370アセンブラ
I8080機械言語
COBOL
BASIC3種類
C
C++
Java
HTML
PHP
SQL
JavaScript

思い出せないくらい言語を学んできた。
機械で言えば、

汎用機からパソコン、マイコンまでということになるなあ。


で、

最近、辿り着いたのが、
Python(パイソン)という言語です。

これが、なんとも便利この上ない。
ライブラリも揃っていて、

importすればすぐに使える!!

AIの機械学習だって、プログラミングできる。
グラフも描ける。

さらに型は自動判定。

アナコンダという開発環境を使えば、
インタープリター的に使える。(実際は、実行してコンパイルしなければなりませんが)

Pythonの使い方は、キノコードさんのYoutube動画をみるとわかりやすいです。
ぜひみなさんも、AIプログラミングしてみまsんか!!

今日は、この辺で。

月軌道のプログラム作ってみた

まあ、ぼちぼち色々なプログラムを作っていますが、最終的に月軌道のプログラムを作りたく、日々悪戦苦闘しているわけです。まあ、全然作りかけのプログラムですが、動作するので、V1.0として掲載してみます。

とりあえず、2回の衝突軌道と地心距離のグラフを作ってみましたが、ほんととりあえずです。

月軌道プログラム(Python)

出力結果

双曲線軌道(侵入系)-Pythonプログラム

双曲線侵入系のプログラムができましたので、アップします。

プログラム概要(仕様ではありませんので悪しからず)

  1. 宇宙船Pが、地球地表から260.9kmの地点で燃料を噴し、地球軌道から太陽の双曲線軌道に移り、木星に向かう軌道に乗ります。
  2. 木星の影響圏に入ったら、太陽軌道から木星への双曲線軌道に移ります。
  3. 木星軌道に乗ったら、木星の地表から2.253020e6を近点とした双曲線軌道に移りスイングバイします。
  4. 地球脱出時の宇宙船X速度は、42.5km/s,半交軸距離は4.25e9kmです
  5. 木星に到着時の宇宙船Xの速度は、19.07km/sになっています。
  6. 木星の影響圏の突入角度は、75.941度です。(基準軌道接線との角度)
  7. 木星の近点での速度は、23.7km/sになります。
  8. スイングバイして脱出するときは、影響圏に入った時と同じ速度になります。
  9. ただし、木星の公転軌道速度が加わりますので、脱出時の脱出角度により速度が増減します。(今回のプログラムでは、計算していません。)

プログラム

結果

※単位 je=kg(km/h)2
-------------------------------------
<宇宙用定数>
-------------------------------------

光速 c = 1079252848.8 km/h , 宇宙エネルギー定数 U = 7.42426e-31 km/kg

-------------------------------------
<軌道用定数>
-------------------------------------

太陽質量     M  = 1.98910e+30 kg
地球質量     m  = 1.89813e+27 kg
宇宙船質量    mp = 1.00000e+03 kg
太陽-地球間距離 Re = 1.49598e+08 km
木星近点     r  = 2.32451e+06 km


-------------------------------------
<地球->木星 vp>
-------------------------------------

太陽-木星間距離   Rp = 7.99920e+08 km
半交軸          ap  = 4.17590e+09 km
地球脱出速度     ve  = 4.24994e+01 km
木星到着速度     vp  = 1.90690e+01 km


-------------------------------------
<侵入(影響圏半径) R>
-------------------------------------

距離       R   = 1.18049e+07 km
速度       vR  = 1.90690e+01 km/h
角度       θR  = 7.59410e+01 度
速度(基準軌道) vHR = 4.63228e+00 km/h
速度(中心天体) vVR = 1.84978e+01 km/h
エネ(基準軌道) AHR = 2.78095e+11 je
エネ(中心天体) AVR = 4.43452e+12 je


-------------------------------------
<侵入(半交軸) a>
-------------------------------------

<侵入(半交軸) a>
距離       a   = 7.36969e+32 km
速度       va  = 3.20392e+01 km/h
角度       θa  = 3.52644e+01 度
エネ(基準軌道) AHa = 8.86905e+12 je
エネ(中心天体) AVa = 4.43452e+12 je
速度(基準軌道) vHa = 2.61599e+01 km/h
速度(中心天体) vVa = 1.84978e+01 km/h

-------------------------------------
<侵入(近点) r>
-------------------------------------

距離       r   = 2.32451e+06 km
速度       vr  = 2.36668e+01 km/h
角度       θ   = 6.05624e+01 度
速度(基準軌道) vHr = 1.04390e+01 km/h
速度(中心天体) vVr = 1.84978e+01 km/h
エネ(基準軌道) AHr = 1.41229e+12 je
エネ(中心天体) AVr = 4.43452e+12 je

双曲線起動-脱出系 プログラムを作ってみた

ダウンロードして使ってみてください。

次のような結果が表示されます

光速 c = 1079252848.8 km/h , 宇宙エネルギー定数 U = 7.42426e-31 km/kg

太陽質量     M  = 1.98910e+30 kg
地球質量     m  = 5.97219e+24 kg
宇宙船質量    mp = 1.00000e+03 kg
太陽-地球間距離 Re = 1.49598e+08 km
地球半径     r  = 6.37814e+03 km

<脱出(近点) r>
距離       rp  = 6.63904e+03 km
速度       vX  = 1.22939e+01 km/h
角度       θ   = 2.69726e+01 度
速度(基準軌道) vHr = 1.09566e+01 km/h
速度(中心天体) vVr = 5.57606e+00 km/h
エネ(基準軌道) AHr = 1.55581e+12 je
エネ(中心天体) AVr = 4.02958e+11 je

<脱出(半交軸) a>
距離       a   = 1.28166e+04 km
速度       va  = 9.65802e+00 km/h
角度       θa  = 3.52644e+01 度
エネ(基準軌道) AHa = 8.05916e+11 je
エネ(中心天体) AVa = 4.02958e+11 je
速度(基準軌道) vHa = 7.88574e+00 km/h
速度(中心天体) vVa = 5.57606e+00 km/h

<脱出(影響圏半径) R>
距離       R   = 2.56332e+04 km
速度       vR  = 7.88574e+00 km/h
角度       θR  = 4.50000e+01 度
エネ(基準軌道) AHR = 4.02958e+11 je
エネ(中心天体) AVR = 4.02958e+11 je/h
速度(基準軌道) vHR = 5.57606e+00 km/h
速度(中心天体) vVR = 5.57606e+00 km/h

第三宇宙速度 計算プログラム作ってみた

ダウンロードして使ってみてください。

次のような結果が表示されます。

光速 c = 1079252848.8 km/h , 宇宙エネルギー定数 U = 7.42426e-31 km/kg

太陽質量     M  = 1.9891e+30 kg
地球質量     m  = 5.97219e+24 kg
宇宙船質量    mp = 1000 kg
太陽-地球間距離 Re = 149598262 km
地球半径     r  = 6378.137 km

地球公転速度          = 2.97861e+01 km/s
太陽圏外脱出速度       = 4.21238e+01 km/s
地球公転速度差引速度   = 1.23377e+01 km/s
地球脱出速度       = 1.11785e+01 km/s

第3宇宙速度      = 1.66486e+01 km/s

素数は宇宙の秘密かな

素数について

そもそも、
素数って何かは、小学校の頃に習っているので、わかっていると思いますが、
1と自分自身の数字でしか割り切れない正の自然数です。
1は素数ではありません。までは定義なので、
そうかと思わざるを得ないのですが。
具体的には、
2、3、5、7、11、13、17、19、23…と続きます。

また、素数の分布について、「リーマン予想」という有名な予想がありまして、
リーマンゼータ関数零点が、負の偶数と、実部が 1/2 の複素数に限られる」という予想です。
このリーマン予想が証明されれば、
この気まぐれな素数の並び方に何らかの大切な意味が隠かくされていることが明らかになる。
と言われています。
(どうしてかは、私にはわかりませんが)

それどころか、素数は大宇宙が従う自然法則に関わる創造主の暗号ではないか。
と考える人さえいます。

ということで、
素数は宇宙に関係あるのではないかということで、
少し取り上げてみます
。ζ関数(ゼータ関数)やリーマン予想については、専門書を読んでいただかないと、
私の拙い知識では、説明できませんので。

素数について、もう少し語ると、
最近は暗号化技術の中で使用されています。
それは大きな数の素因数分解は難しいというところから、
鍵として使われています。
簡単に言うと、Aさんが鍵3を持っていて Bさんが鍵5を持っているとします。
Aさんが暗号化キー15を送ったすると、Bさんは鍵5で割ってAさんの鍵が3てわかります。
実際は桁数がすごい多い数を使うのですが。
2018年12月現在で知られている最大の素数は、
2018年12月に発見された、
それまでに分かっている中で51番目のメルセンヌ素数 282589933 − 1 で、
十進法で表記したときの桁数は2486万2048桁になります。
気が遠くなりますが。

素数の判定法

与えられた自然数 n が素数であるか合成数であるかを判定するためのアルゴリズムが多数考案されています。
最も素朴な方法は、2 から √n 以下の素数まで順番に割っていく、
試し割りと呼ばれる方法です。
n が √n 以下の全ての素数で割り切れなければ n は素数である。
試し割りは、n が大きくなるに従って、急速に速度が低下するため、
実用的ではありませんが。
任意の数に適用できる試し割りよりも高速なアルゴリズムが考案されています。

また、特殊な形をした数に対してはより高速なアルゴリズムも存在します。
素数判定は、与えられた数が素数であるか否かだけを判定するものですが、
素因数分解とはより強く、
与えられた数の全ての素因数を列挙することでもあります。

ほぼほぼ同じ要領のエラトステネスの篩(ふるい)があります。また、他の判定法としては、

ウィルソンの定理 ― p が素数ならば (p − 1)! ≡ −1 (mod p) が成り立つ。
逆に、整数 p > 1 に対し、(p − 1)! ≡ −1 (mod p) ならば、p は素数である

最大公約数 ー 2つ以上の整数  の最大公約数が1 であるとき、 は互いに素であるという。
公約数は最大公約数の約数である。

ミラー–ラビン素数判定法、AKS素数判定法 などあります。が、よくわかりません。汗

そこで、自分なりの判定法を考えてみました。

ENDY素数判定法

Pn(素数)までの全ての素数がわかっている時、
どこまでの素数が判定できるかという事を考えてみます。

ゾーン1:2からPnの素数は判定済です。

ゾーン2:Pn+1からPn+1^2(非素数) までの数は「判定可能」です。

ゾーン3:Pn+1^2+1 より大きい数は「判定不可能」です。

というゾーンに分かれます。

ゾーン2の判定方法は嗣のように定義します。

f(Pn)=Πsin(πPn/n) n=2,3…Pn+1 → f(Pn)≠0…素数 、f(Pn)=0…非素数

Pn=5をグラフ化すると

となります。グラフの5より大きいゼロでない数(7、11、13、17、19、23…)が素数になります。確実に判定できるのは7の二乗の49(非素数)までです。
その範囲を判定可能領域と呼びます。
この方法は、素数の可視化が簡単ですが、
欠点は、サインを使用しているため、
コンピューターで計算するとフーリエ展開の誤差でうまくゼロにならないところです。
また桁数が大きくなると、グラフが限りなくゼロに近づいていくので、
拡大する定数を掛けないとならないところです。
しかし、理論的には、一つの公式で素数が判別でき、
判定可能領域の素数の数が把握できます。ということは、判定可能領域ごとの素数分布を捉えることが可能ということです。素数の分布を調べてみたので、したのグラフに表す。右側の数字は、その近辺の素数分布率(素数/実際の数字の数)です。

10の場合、Pn=3、次の素数5の二乗25なので 9から25が判定可能範囲なので、その範囲の素数の5個を数えてます。(9から25) 母数に9は含みません。5÷ 16 =31.25

100の場合、Pn=7、次の素数11の二乗の判定可能範囲49から121

1000の場合、Pn=31、次の素数37の二乗の判定可能範囲961から1369

10000の場合、Pn=97、次の素数101の二乗の判定可能範囲9409から10201)

1000000の場合、Pn=997、次の素数1009 の二乗の判定可能範囲994009から1018081

10000000の場合、Pn=3137、次の素数3163 の二乗の判定可能範囲9840769から10004569

でサンプリングしました。

例えば、1,000,000の場合、
1,000の一番近くの素数997の二乗と1009の二乗の間にあります。
Pn=997が決まれば、1,000,000近くの素数の数が分かります。
グラフを見る限り数が大きくなればなるほど、判定可能範囲の数は減っていきます。

さらに大きな数になれば、判定可能範囲は広くなりますが、素数は減ってくるはずです。

ところが、素数は無限にあることは証明されているので、
0%にはならず、有限なところで収束するはずです。

どこか漸近線があるのではないかと推測できます。
限りなくゼロに近づくのでしょうか。

宇宙の構造と素数の因果関係は、
まだ分かりませんが、なんとなく静的エネルギーの減少(Sa=EA/a)に似ている気がします。
何の証明もしていませんが。
遠ざかるほど小さくなるところが。
本質的なところでは、まだ分かりません。

上の素数分布のPythonのプログラムを参考に載せておきます。