Multivariable Calculus from MIT OpenCourseWare

Trochę na fali ostatniego zamieszania z blokowaniem kilku popularnych kanałów jak Blender i MIT Courses.

• https://torrentfreak.com/youtubes-piracy-filter-blocks-mit-courses-blender-videos-and-more-180618/

Postanowiłem wspomnieć o jednym z nich: "MIT 18.02 Multivariable Calculus, Fall 2007". Genialny kurs jeżeli, ktoś chce uzupełnić/przypomnieć sobie materiał ze studiów. Filmiki, w wypadku następnej blokady przez youtube, zawsze można pobrać, korzystając z linków na stronie kursu:

• https://ocw.mit.edu/courses/mathematics/18-02-multivariable-calculus-fall-2007/

Rachunek wektorowy i książki

Kilka przydatnych książek, które znalazłem na wikibooks, ucząc się fizyki. Niektórym brakuje rozdziałów, ale i tak jestem pod wrażeniem. Warto się temu przyjrzeć, jako coś dodatkowego do klasycznych podręczników:

• https://pl.wikibooks.org/wiki/Mechanika_teoretyczna
• https://pl.wikibooks.org/wiki/Metody_numeryczne_fizyki
• https://pl.wikibooks.org/wiki/Metody_matematyczne_fizyki
• https://pl.wikibooks.org/wiki/Analiza_matematyczna

Coś z rachunku wektorowego - wirujący wektor, do którego stworzenia potrzebna jest macierz obrotu [1], [2].

Program koduj macierze przekształceń właściwą dla dwóch wymiarów:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from visual import *
import ImageGrab

display(x=0, y=0, width=400, height=400, userzoom=False,
        center=(0, 0, 1), foreground=(0, 0, 0), background=(1, 1, 1))

ar = arrow(pos=(0, 0, 0), axis=(10, 0, 0), shaftwidth=0.3)

total_angle = 0
angle = 0.1 / (2 * math.pi)
frame = 0
while total_angle <= 2 * math.pi:
    rate(100)

    nx = ar.axis.x * math.cos(angle) - ar.axis.y * math.sin(angle)
    ny = ar.axis.x * math.sin(angle) + ar.axis.y * math.cos(angle)
    nz = 0
    ar.axis = (nx, ny, nz)

    file_name = 'img-' + '{fr:03d}'.format(fr=frame) + '.png'
    frame += 1

    im = ImageGrab.grab((0, 0, 400, 400))
    im.save(file_name)

    total_angle += angle
    print total_angle

exit()

[python] matplotlib - rysowanie wykresów

Kolejna biblioteka, którą zacząłem się bawić, służąca do rysowania wykresów: matplotlib. Bardzo przyjema dokumentacja, z dużą liczbą przykładów. Dla testu wykreśliłem pochodną i całkę oznaczoną dla funkcji:
$$ f(x) = -2x^{3} - 4x^{2} + 8x + 1 \\
f^\prime(x) = -6x^{2} - 8x + 8 \\
F(x) = \int f(x) dx = -\frac{1}{2}x^{4} - \frac{4}{3}x^{3} + 4x^{2} + x + C \\
F(-3) - F(1) = \int_{-3}^{1} f(x) dx = \left(-\frac{1}{2}x^{4} - \frac{4}{3}x^{3} + 4x^{2} + x + C\right)\Biggr|_{-3}^{1} $$

Kod programu:

#!/usr/bin/env python
# -*- coding: utf-8 -*-


import numpy as np
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt


def main():
    red_patch = mpatches.Patch(color='red', label=r'$f(x)$ - moja funkcja')
    blue_patch = mpatches.Patch(color='blue', label=r'$f^\prime(x)$ - obliczone numerycznie')
    cyan_patch = mpatches.Patch(color='cyan', label=r'$f^\prime(x)$ - obliczone recznie')
    green_patch = mpatches.Patch(color='green', label=r"$\int_{-3}^{1}f(x)$ - obliczone numerycznie")

    plt.legend(handles=[red_patch, blue_patch, cyan_patch, green_patch], loc='lower right')

    x = np.linspace(-4, 2, 10)
    x_dense = np.linspace(-4, 2)

    y_f = func(x)
    plt.plot(x, y_f, 'red', linewidth=2)

    y_deriv = derivative(func, x)
    plt.plot(x, y_deriv, 'blue', linewidth=2)

    y_own_deriv = own_deriv_func(x_dense)
    plt.plot(x_dense, y_own_deriv, 'cyan', linewidth=1)

    summo1 = definite_integral(func, a=-3, b=1)
    summo2 = own_integral_func(a=-3, b=1)
    print 'Całka oznaczona, numerycznie: %f' % summo1
    print 'Całka oznaczona, ręcznie: %f' % summo2

    current_figure = plt.gcf()
    current_figure.savefig('rachunek_rozniczkowy.png')

    plt.show()


def func(x):
    return -2 * (x ** 3) - 4 * (x ** 2) + (8 * x) + 1


def own_deriv_func(x):
    return -6 * (x ** 2) - 8 * x + 8


def own_integral_func(a, b):
    F = lambda x: -(1/2.0) * (x ** 4) - (4/3.0) * (x ** 3) + 4 * (x ** 2) + x
    return F(b) - F(a)


def derivative(fun, x):
    h = 0.2 # dx
    return (fun(x + h) - fun(x)) / h


def definite_integral(fun, a, b):
    axes = plt.gca()
    dx = (b - a) / 20.0

    summo = 0
    x = a
    while x < b:
        axes.add_patch(mpatches.Rectangle(xy=(x, 0), width=dx, height=fun(x), facecolor='green'))
        summo += dx * fun(x)
        x += dx

    return summo


if __name__ == '__main__':
    main()

Wynik:

Całka oznaczona, numerycznie: -26.080000
Całka oznaczona, ręcznie: -25.333333

MathJax - Hello World

Test MathJax do zapisywania formuł matematycznych.

Niech \(f\) będzie funkcją ciągła zdefiniowaną dla \( a \leq x \leq b \). Przedział \( [a, b] \) będzie podzielony \( n \) podprzedziałów o równej długości wynoszącej \( \Delta x = \frac{(b - a)}{n} \), tak że \(x_{0} = a \), a \( x_{n} = b \), będącymi końcami tych podprzedziałów i niech \( x_{1}^*, x_{2}^*,... , x_{n}^* \) będą dowolnymi punktami próbkującymi w tych przedziałach, \( x_{i}^* \in [x_{i-1}, x_{i}] \). Wówczas całkę oznaczoną z funkcji \( f \) w przedziale od \( a \) do \( b \) oznaczamy i definiujemy jako:

$$ \int_{a}^{b} f(x) dx = \lim_{n\to\infty} f(x)\sum_{i=1}^{n} f(x_{i}^*) \Delta x $$