Dieser Artikel ist der 17. Tagesartikel von Python Advent Calendar 2015. Wieder [Python](http: //www.adventar.org/) aus Mathematics Advent Calendar 2015 und ADVENTAR //www.adventar.org/calendars/846) und Math dienen auch als 17. Tag m (_ _) m
Dies ist ein inspirierender Artikel von Programmatic Mathematics IA 2015 programmatisch lösen (Python). Ich hatte viel Spaß dabei, also habe ich Mathematik IIB ausprobiert und Sympy studiert.
Prüfung des Aufnahmeprüfungszentrums der Universität | Antwortbulletin 2015 | Toshin der Vorbereitungsschule Mathematik II / Mathematik B http://www.toshin.com/center/sugaku-2b_mondai_0.html
https://github.com/massa142/mathematics-2b
Zunächst werde ich zusammenfassen, wie Sympy verwendet wird, das danach häufig erscheint.
Python-Symbolberechnungsbibliothek Offizielles Dokument: http://www.sympy.org/en/index.html Japanische Übersetzung: http://turbare.net/transl/scipy-lecture-notes/index.html
In [1]: from sympy import *
In [2]: x + 1
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-2-4cf92658b648> in <module>()
----> 1 x + 1
NameError: name 'x' is not defined
In [3]: x = symbols('x')
In [4]: x + 1
Out[4]: x + 1
In [5]: expand((x + 1)**2)
Out[5]: x**2 + 2*x + 1
In [6]: factor(x**4 - 3*x**2 + 1)
Out[6]: (1 + x - x**2)*(1 - x - x**2)
In [7]: simplify((x**3 + x**2 - x - 1)/(x**2 + 2*x + 1))
Out[7]: x - 1
In [8]: limit(x, x, oo)
Out[8]: oo
In [9]: diff(cos(x), x)
Out[9]: -sin(x)
In [10]: diff(x**3 + x**2 - x - 1, x)
Out[10]: 3*x**2 + 2*x - 1
In [11]: integrate(cos(x), x)
Out[11]: sin(x)
In [12]: integrate(x**3 + x**2 - x - 1, x)
Out[12]: x**4/4 + x**3/3 - x**2/2 - x
In [13]: Matrix([[1, 2, 3], [-2, 0, 4]])
Out[13]:
Matrix([
[ 1, 2, 3],
[-2, 0, 4]])
In [14]: solve(x**2 - 1, x)
Out[14]: [-1, 1]
Das Problem der Koordinaten ist in Ordnung, wenn Sie mit Sympys Matrix über jeden Punkt in einem Vektor nachdenken. Lassen Sie uns vorerst θ zur Vereinfachung auf 45 ° einstellen.
import math
import sympy as sy
import numpy as np
γ = sy.pi/4
O = sy.Matrix([0, 0])
P = sy.Matrix([2*sy.cos(γ), 2*sy.sin(γ)])
Q = sy.Matrix([2*sy.cos(γ) + sy.cos(7*γ), 2*sy.sin(γ) + sy.sin(7*γ)])
Der Abstand zwischen zwei Punkten kann durch das Konzept der Norm einer Matrix ausgedrückt werden. http://docs.sympy.org/0.7.2/modules/matrices/matrices.html#sympy.matrices.matrices.MatrixBase.norm
(O - P).norm()
(P - Q).norm()
Ausgabe
2 #EIN
1 #ich
Der nächste $ OQ ^ 2 $ scheint ehrlich berechnet zu werden. Diese Berechnung hängt vom Wert von θ ab, daher können die zuvor eingegebenen 45 ° nicht verwendet werden ... Definieren wir ein neues θ als Symbol.
#Symbolisieren Sie θ als einen Wert größer als 0
θ = sy.symbols('θ', positive=True)
sy.simplify((2*sy.cos(θ) + sy.cos(7*θ))**2 + (2*sy.sin(θ) + sy.sin(7*θ))**2)
4*cos(6*θ) + 5 #C.,D.,Oh
Nachdem ich es vereinfacht hatte, konnte ich eine nette Antwort finden. Betrachten Sie als nächstes den Maximalwert von OQ. Dies scheint ein wenig problematisch zu sein, daher werde ich die Lösungsmethode der Round-Robin-Berechnung unter Verwendung der Tatsache verwenden, dass die Antwortspalte [ka] eine Ziffer einer Ganzzahl ist.
for n in range(4, 9):
γ = math.pi / n
print("θ ist π/"+ str(n) + "Zu diesem Zeitpunkt OQ**Der Wert von 2 ist" + str(5 + 4*np.cos(6*γ)))
θ ist π/Wenn 4, OQ**Der Wert 2 ist 5.0
θ ist π/Wenn 5, OQ**Der Wert 2 ist 1.7639320225
θ ist π/Bei 6, OQ**Der Wert 2 ist 1.0
θ ist π/Wenn es 7 ist, OQ**Der Wert 2 ist 1.39612452839
θ ist π/Wenn es 8 ist, OQ**Der Wert von 2 ist 2.17157287525
Es stellt sich heraus, dass der Maximalwert genommen wird, wenn "θ = π / 5" ist. [F]: 5
Der zu diesem Zeitpunkt angenommene Wert betrug 1,7639320225. Sie können intuitiv verstehen, um welche Quadratwurzel sich dieser Wert handelt, aber berechnen wir ihn für alle Fälle.
from fractions import Fraction
#Finden des optimalen Bruchs mit einem Nenner von 1 oder weniger
Fraction(1.7639320225**2).limit_denominator(1)
Fraction(3, 1)
Da sich herausstellte, dass $ 1.7639320225 ^ 2 ≒ 3 $, wurde auch der Wert von [ki] erhalten. [Ki]: 3
Die Gleichung, die die gerade Linie OP darstellt, kann durch geheime Berechnung verstanden werden, so dass sie weggelassen wird. [K]
(\sin\theta)x - (\cos\theta)y = 0
Da die drei Punkte O, P und Q auf einer geraden Linie liegen, ist es in Ordnung, wenn Sie die Koordinaten des Punktes Q in die obige Formel einsetzen.
sy.simplify(sy.sin(θ)*(2*sy.cos(θ)+sy.cos(7*θ))-sy.cos(θ)*(2*sy.sin(θ)+sy.sin(7*θ)))
Ausgabe
-sin(6*θ)
# _Erhält den vorherigen Ausgabewert
sy.solve(_)
Ausgabe
[pi/6] #Ke
Ja als nächstes! Das ist wirklich einfach. Der Winkel OQP wird ein rechter Winkel von OP = 2, PQ = 1 [Co]: $ OQ = \ sqrt3 $
Verwenden Sie diesen Wert und den in [c] [d] [e] erhaltenen Wert von OQ, um θ zu finden, wenn der Winkel OQP ein rechter Winkel wird.
# 5+4*sy.cos(6*θ) =Ab 3
sy.solve(5+4*sy.cos(6*θ) - 3)
Ausgabe
[pi/9, 2*pi/9]
$ \ pi / 8 \ leqq θ \ leqq \ pi / 4 $ Warum $ θ = 2/9 \ pi $ [sa] [shi]
import math
import sympy as sy
import numpy as np
x, y, a, b = sy.symbols('x y a b', real=True, positive=True) #Symbolisiert als positive reelle Zahl
c1 = x**2*y**3 - a**2
c2 = x*y**3 - b**3
sy.solve({c1, c2}, {x, y})
Ausgabe
[{y: b**2/a**(2/3), x: a**2/b**3}] #Su,Se,Damit,Ta
Ich konnte es sofort mit lösen lösen!
Achten Sie danach auf den Wert von y und finden Sie den Wert von p. [Chi] [Tsu] [Te]
Ersetzen Sie "b = 2 * a ** (4/3)" durch x bzw. y, die oben berechnet wurden. Zuerst von x.
sy.simplify(a**2/(2*a**(4/3))**3)
Ausgabe
a**(-2.0)/8 #Zu,N / a
Und du auch.
sy.simplify((2*a**(4/3))**2/a**(2/3))
Ausgabe
4*a**2.0 #D.
Wenn Sie hier den Mindestwert von x + y berücksichtigen und die Leistung von Scipy verwenden, müssen Sie sich nicht an die Formel "Beziehung zwischen additivem Durchschnitt und synergistischem Durchschnitt" erinnern!
from scipy.optimize import differential_evolution
#Konvertieren Sie a, ein Symbol, so dass es als numerischer Wert behandelt werden kann
numeric_a = sy.lambdify(a, a**(-2.0)/8 + 4*a**2.0)
#Der Bereich von a ist a>0 Die Obergrenze ist der maximale int-Wert in der Python2-Serie
#A ist 0 in roher Gewalt~Finden Sie den Mindestwert zwischen 2147483647
differential_evolution(numeric_a, [(0, 2**31-1)])
Ausgabe
nfev: 518
success: True
nit: 33
jac: array([ 7.06101844e-06])
message: 'Optimization terminated successfully.'
fun: array([ 1.41421356])
x: array([ 0.42044842])
Aus diesem Ergebnis Es ist ersichtlich, dass "wenn a = 0,42044842 ist, x + y den Mindestwert 1,41421356 annimmt".
Danach ist es in Ordnung, wenn Sie "0,42044842 ist die Potenz von 2" und "1,41421356 ist die Quadratwurzel" berechnen.
from fractions import Fraction
math.log2(0.4204482)
Fraction(_).limit_denominator(9)
Ausgabe
Fraction(-5, 4) #Ne,Nein,C.
Fraction(1.41421356**2).limit_denominator(1)
Ausgabe
Fraction(2, 1) #Nu
Endlich ist die erste Frage vorbei (´-ω-`)
Lassen Sie die zweite, dritte und vierte Frage weg
People People People People People > Plötzliche 5. Frage <  ̄Y^Y^Y^Y^Y^Y^Y^ ̄
Die Berechnung von Kombinationen ist mit einem Modul namens Scipy.misc.comb einfach. http://docs.scipy.org/doc/scipy/reference/generated/scipy.misc.comb.html#scipy.misc.comb
import itertools
import scipy.misc as scm
scm.comb(7, 3, exact=True)
Ausgabe
35 #ich,C.
scm.comb(4, 0, exact=True)*scm.comb(3, 3, exact=True)
scm.comb(4, 1, exact=True)*scm.comb(3, 2, exact=True)
scm.comb(4, 2, exact=True)*scm.comb(3, 1, exact=True)
scm.comb(4, 3, exact=True)*scm.comb(3, 0, exact=True)
Ausgabe
1 #EIN
12 #D.,Oh
18 #Leistung,Ki
4 #Ku
#Im Wörterbuch gespeichert, um erwartete Werte und Abweichungen zu berechnen
dict = {0: 1/35, 1: 12/35, 2: 18/35, 3: 4/35}
mean = sum(x*y for x, y in dict.items())
from fractions import Fraction
Fraction(mean).limit_denominator(9)
Ausgabe
Fraction(12, 7) #Ke,Ko,Bedienung
variance = sum(x*x*y for x, y in dict.items()) - mean**2
Fraction(variance).limit_denominator(99)
Ausgabe
Fraction(24, 49) #Shi,Su,Se,Damit
Es ist eine Standardnormalverteilung herausgekommen, aber dies ist auch in Ordnung, wenn Sie die statistische Bibliothek von Scipy verwenden. http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.norm.html#scipy.stats.norm
Jetzt müssen Sie nicht mehr auf diesen regulären Verteilungstisch blicken!
from scipy.stats import norm
norm.interval(alpha=0.99)
Ausgabe
(-2.5758293035489004, 2.5758293035489004) #Ta
import sympy as sy
from scipy.stats import norm
n, σ = sy.symbols('n σ')
norm.interval(alpha=0.95)
norm.interval(alpha=0.99)
Ausgabe
(-1.959963984540054, 1.959963984540054)
(-2.5758293035489004, 2.5758293035489004)
L1 = 2*1.96*σ/sy.sqrt(n)
L2 = 2*2.58*σ/sy.sqrt(n)
L2/L1
Ausgabe
1.31632653061224 #Ji,Tsu
L3 = 2*1.96*σ/sy.sqrt(4*n)
L3/L1
Ausgabe
0.500000000000000 #Te,Zu
Nachdem ich die grundlegende Verwendung von Sympy gelernt hatte, war es einfach, das Niveau der Center-Prüfung zu erreichen. Der Eindruck, diesmal zu versuchen, ist so.
Recommended Posts