<repo_name>chcko/chcko-r<file_sep>/chcko/r/cr/de.rst
.. raw:: html

    %path = "Mathe/Funktionen"
    %kind = chindnum["Texte"]
    %level = 9
    <!-- html -->

Eine **Funktion (= Abbildung)** kann als Menge von Wertepaaren `(x,y)` mit
`x\in X` (**Definitionsmenge**) und `y\in Y` (**Wertemenge**) identifiziert
werden.  Wichtig ist die **Eindeutigkeit**: für ein `x` gibt es genau ein `y`.
`x` kann man aus einer Menge frei wählen.
Man nennt `x` **unabhängiger Wert, Urbild, Veränderliche, Argument oder Stelle**.
`y` ist durch `x` bestimmt. Es ist keine zusätzliche Information notwendig.
Das macht letztendlich den Begriff Funktion wichtig.
Man nennt `y` **abhängige Variable, Bild oder Funktionswert**.

Ist diese Eindeutigkeit nicht gegeben, dann spricht man von einer **Relation**.

Ein Funktion `f` hat ein Richtung von der Menge aller `x` (`X`) auf die Menge
aller `y` (`Y`). Man schreibt `f:X\rightarrow Y`.

Die Wertepaare können normalerweise nicht alle angegeben werden,
deshalb beschreibt man eine Funktion mit einer Rechenvorschrift,
d.h. einem **analytischen Ausdruck**, z.B. `y=x^2+1`.
Das ist im Grunde ein Algorithmus, ein kleines Programm.

.. admonition:: Grundkonzepte:

    - Definitionsmenge
    - Wertemenge
    - Abbildung

Wenn man keinen eigenen Buchstabe `f` für die Funktionen haben will,
kann man auch schreiben: `y(x)`, d.h. die Klammern sagen aus,
dass `y` sich aus `x` eindeutig ergibt, d.h. Funktion von `x` ist.
Manchmal kann `f` die Funktion meinen oder den Funktionswert.

Konzentriert man sich nur auf die Abbildung, so schreibt man statt `g(f(x))`
auch `g\circ f` und das heißt: bilde zuerst mittels `f`, dann mittels `g` ab,
d.h. von rechts nach links in beiden Schreibweisen.

Es kann mehrere `x` mit gleichem `y` geben und es ist immer noch eine Funktion.
Gibt es nur ein Urbild `x` für ein Bild `y`, dann ist die Funktion
linkseindeutig (**injektive**), d.h. sie bewart Unterscheidbarkeit oder
verliert nicht an Information.
Wird darüber hinaus noch jedes element der
Bildmenge erreicht (**surjektiv**), dann ist die Funktion unkehrbar eindeutig,
eineindeutig oder **bijektiv**.  Dann kann man auch `y` beliebig wählen und `x`
ist dadurch bestimmt (`x(y)`, **Umkehrfunktion**).

Wenn die Bilder von Elementen, die sich nahe sind, auch nahe beisammen sind,
dann ist die Funktion **stetig**. Nahe ist intuitiv, muss aber mathematisch
erst definiert werden.  Das geschieht über eine **Metrik** `d` (`d(x,y)\ge 0`,
`d(x,y)=d(y,x)` und `d(x,z)\le d(x,y)+d(y,z)`, z.B. `d(x,y)=|y-x|`)
(oder auch abstrakter in der Topologie über eine Menge von (offenen) ineinander
verschachtelten Mengen.)

.. admonition:: Stetigkeit bei `x`

   Für jedes `\varepsilon > 0` gibt es eine `\delta`, so dass
   für alle y mit `d(x,y)<\delta` gilt: `d(f(x),f(y))<\varepsilon`.

   Für jede `\varepsilon`-Umgebung gibt es eine `\delta`-Umgebung.

Eine Funktion setzt keine Ordnung voraus. Ist sie aber gegeben,
dann sagt man eine Funktion ist **(streng) monoton** steigend,
wenn aus `x\le y` (`x<y`) folgt: `f(x)\le f(y)` (`f(x)<f(y)`).
(Streng) monoton fallend wird analog definiert.

Verwandt mit Funktion ist Morphismus (:lnk:`r.cs`).

Zur graphischen Darstellung einer Funktion in einem **Koordinatensystem**:

- Werden die Werte der beteiligten Variablen `X` und `Y` mittels einer Einheit
  auf Zahlen abgebildet
- Es wird eine Längeneinheit für die Darstellung gewählt (z.B. cm).
  Das Verhältnis dieser Längeneinheit zur realen Einheit (kg, km, m/s,...) ist
  der **Maßstab**.
- Für einen Wert der unabhängigen Variablen `X` geht man den Zahlenwert
  in dieser Längeneinheit nach links (`x`-Koordinate, Abszisse).
- für einen Wert der abhängige Variable `Y` geht man den Zahlenwert
  in dieser Längeneinheit nach oben (`y`-Koordinate, Ordinate).
- Das wiederholt man für einige Werte und man erhält Punkte
  Die `(x,y)`-Paare dieser Punkte kann man als Zwischenschritt auch
  in eine Tabelle eintragen (**Wertetabelle**).
- Weil es sich meistens um stetige Funktionen handelt,
  kann man eine Kurve durch diese Punkte legen.
  Ist die Kurve eine Gerade, dann spricht man von einer **linearen Funktion**.

Beispiele für Graphen von bestimmten grundlegenden Funktionstypen mit
einer unabhängigen Variablen gibt es hier: :lnk:`r.cf`.

<file_sep>/chcko/r/a3/__init__.py
from chcko.chcko.hlp import Struct
import numpy as np
import pint
u = pint.UnitRegistry()
import random
def chiven():
    g = Struct()
    g.Vcc = random.choice(range(7,15))*u.V
    g.Vi = random.choice(range(4,g.Vcc.magnitude-2))*u.V
    g.Vo = random.choice(range(1,g.Vi.magnitude))*u.V
    g.hfe = random.choice(range(5,15))*10
    g.Icmax = random.choice(range(5,15))*u.mA
    g.Vbe = random.choice([0.3,0.7])*u.V
    return g
def chalc(g):
    #g = chiven()
    VceCutoff = g.Vcc
    VceSaturation = 0
    ReRc = (g.Vcc-VceSaturation)/g.Icmax
    #Rc = (g.Vcc/g.Vo-1)*Re
    Re = ReRc*g.Vo/g.Vcc
    Rc = ReRc - Re
    Ibmax = g.Icmax/g.hfe
    Rb = (g.Vi-g.Vo-g.Vbe)/Ibmax
    res = [x.to('kΩ').magnitude for x in [Rc,Re,Rb]]
    return res
chames = [r'\(R_c/kΩ=\)', r'\(R_e/kΩ=\)', r'\(R_b/kΩ=\)']
P = lambda x: "{:~P}".format(x)

<file_sep>/chcko/r/cr/en.rst
.. raw:: html

    %path = "maths/functions"
    %kind = chindnum["texts"]
    %level = 9
    <!-- html -->

A **function (= mapping)** can be seen as set of value pairs `(x,y)` with
`x\in X` (**domain**, **preimage**) and `y\in Y` (**codomain**, **image**, **range**).
Important is the **uniqueness** of the image: for any `x` there is exactly one `y`.
`x` can be freely chosen. `x` is **independent value, preimage, argument or position**.
`y` is determined by `x`. No new information is needed to select `y`.
This is why functions are important.
`y` is called **(dependent or function) value or image**.

If the uniqueness is not satisfied, then it is called a **relation**.

A function `f` as a direction from the set of all `x` (`X`) to the set
of all `y` (`Y`). This is notated as `f:X\rightarrow Y`.

The value pairs normally cannot be written down because too many or infinite.
Therefore one describes the function via an **analytic expression**, i.e.
`y=x^2+1`. This basically is an algorithm, a program.

.. admonition:: Basic Concepts:

    - domain
    - codomain
    - mapping

If we do not want to have a separate letter `f` for the mapping,
we can write: `y(x)`, i.e. the parentheses say that
`y` follow from `x`, i.e. is function of `x`.
Sometimes `f` can mean both the mapping or the function value.

If we concentrate only on the mapping, instead of `g(f(x))`
we can write `g\circ f` meaning: first we map via `f`, then via `g`,
i.e. the ordering is the same in both writings.

There can be more `x` with the same `y` and it is still a function.
If there is only one preimage `x` for a `y`, then the function
is **injective**, i.e. it keeps the distinction or does not loose information.
If in addition every element of `Y` is reached (**surjective**),
then the function is **bijektive**.
In this case by choosing `y` we also choose `x` (`x(y)`, **inverse function**).

If the images of elements that are close together are also close together,
then the function is **continuous**. Close is intuitive, but still needs
a formal definition. This is done via a **metric** `d` (`d(x,y)\ge 0`,
`d(x,y)=d(y,x)` and `d(x,z)\le d(x,y)+d(y,z)`, e.g. `d(x,y)=|y-x|`)
(or in a more abstract way in topology via sets of nested open sets).

.. admonition:: Continuity at `x`

   For every `\varepsilon > 0` there is a `\delta`, such that
   for all `y` with `d(x,y)<\delta` we have `d(f(x),f(y))<\varepsilon`.

   For every `\varepsilon`-neighbourhood there is a `\delta`-neighbourhood.

A function does not presuppose order of domain and codomain. But if it is given,
then a function is said **(strictly) monotonically increasing**,
if `x\le y` (`x<y`) makes `f(x)\le f(y)` (`f(x)<f(y)`).
Analogously one defines **(strictly) monotonically decreasing**.

Morphisms are related to functions (see :lnk:`r.cs`).

Regarding graphical representation of a function in a **coordinate system**:

- First values of variables `X` and `Y` are mapped via units to numbers
- A unit for the graph is chosen (e.g. cm).
  The ratio of unit in graph to unit in reality (kg, km, m/s,...) is the **scale**.
- For a value of the independent variable `X` one goes the number
  of graph units to the left (`x`-coordinate, abscissa).
- For a value of the dependent variable `Y` one goes the number of
  graph units upward (`y`-coordinate, ordinate).
- This one repeats for a few pairs of values.
  These `(x,y)`-pairs can also be written into a table as a intermediate step
  (**value table**).
- Since usually it will be a continuous function,
  one can connect the points with a continuous line.
  If the line is linear then it is called a **linearen function**.

Examples of graphs for fundamental types of functions of one variable
can be found here: :lnk:`r.cf`.

<file_sep>/chcko/r/d/__init__.py
# -*- coding: utf-8 -*-
import numpy as np
import random
import itertools
from math import log
from sympy.abc import C, U, R, T
from sympy import E
from sympy import simplify

from chcko.chcko.hlp import Struct, norm_rounded

gc = np.array(range(500, 600, 10))  # μF
gu = np.array(range(900, 1000, 10))  # V
gr = np.array(range(150, 250, 10))  # kΩ
gt = np.array(range(20, 30))
curt = list(itertools.product(gc, gu, gr, gt))
num = len(gc) * len(gu) * len(gr) * len(gt)
ee = E ** (-T / (R * C))


def chiven():
    i = random.randrange(num)
    g = Struct()
    g.c, g.u, g.r, g.t = curt[i]
    g.u2 = g.u * E ** (-1e3 * g.t / (g.c * g.r))
    return g


def chalc(g):
    # r,u,u2,t=230,940,773.54,26
    r, u, u2, t = g.r, g.u, g.u2, g.t
    c = 1e3 * t / (r * log(u / u2))
    return ['e^(-t/(R*C))',
            c,
            1e-6 * c * u,
            1e-6 * c * u2,
            1e-3 * r * c * log(2)]


def chorm(answers):
    # answers=chalc(chiven())
    try:
        e = simplify(answers[0].upper())
        a0 = str(e)
    except:
        a0 = answers[0]
    return [a0] + [norm_rounded(a, 2) for i, a in enumerate(answers) if i > 0]
<file_sep>/chcko/r/ca/__init__.py
# -*- coding: utf-8 -*-

from chcko.chcko.hlp import Struct
import random
import numpy as np
from math import acos, pi

__all__ = ['chiven', 'chalc']


def chiven():
    g = Struct()
    g.x = random.sample(range(-9, 9), 2)
    g.y = random.sample(range(-9, 9), 2)
    g.dx = random.sample(list(range(-4, -1)) + list(range(1, 4)), 1)[0]
    return g

angle = lambda a, b: 180 * \
    acos(np.around(np.dot(a, b) / np.linalg.norm(a) / np.linalg.norm(b),6)) / pi
taria = lambda a, b: abs(np.cross(a, b) / 2)


def chalc(g):
    a = angle(g.x, g.y)
    A = taria(g.x, g.y)
    nx = np.linalg.norm(g.x)
    ny = np.linalg.norm(g.y)
    x0 = g.x / np.linalg.norm(g.x)
    y0 = g.y / np.linalg.norm(g.y)
    A1 = taria(g.y, g.y + g.dx * x0)
    res = [a, A, nx, ny, x0[0], x0[1], y0[0], y0[1], A1]
    return res
<file_sep>/chcko/r/co/de.rst
.. raw:: html

    %path = "Mathe/abstrakt-konkret"
    %kind = chindnum["Texte"]
    %level = 9
    <!-- html -->


In der Mathematik so wie im täglichen Leben wird versucht, das **Konkrete**,
das sich wiederholt, einmal zu beschreiben und dann darauf zu verweisen.
Dieses Gemeinsame vieler Beobachtungen ist **abstrakt**. Das macht viele
Beschreibungen kürzer und vermindert vor allem den Gesamtumfang.

Für Lernende ist es aber oft schwierig, die Verbindung mit dem Konkreten wieder
aufzubauen. Abstrakte Definitionen und Sätze werden deshalb am besten mit
Kommentaren begleitet über ihre Motivation, ihre Reichweite, mit Beispielen oder
Anwendungen.

Normalerweise geht man vom Abstracten aus, findet Gemeinsamkeit durch Vergleichen
und das nennt man **Analyse**.  Das Resultat der Analyse ist eine **Abstraktion**.
Informationstechnisch ist das **Reduktion von Redundanz** oder **Kompression**.
Es ist ein grundlegender, im Grunde alltäglicher, kognitiver Vorgang.

.. admonition:: Hinweis

    Als Werkzeug zur Abstraktion wird oft die **Äquivalenzrelation**
    herangezogen.  (= **reflexive, symmetrische und transitive Relation**,
    `\sim`) Dabei konzentriert man sich auf eine (einige) Eigenschaft(en) und
    lässt anderes weg.  Alle Elemente mit einer Ausprägung der Eigenschaft (=
    Wert der Variable) sind äquivalent und bilden zusammen eine
    Äquivalenzklasse.  Alle Äquivalenzklassen bilden die **Quotientenmenge**
    `M/\sim`, eine Menge von disjunkten Teilmengen von `M`.

Abstrakte Beschreibungen können neu kombiniert werden (**Synthese**).  Das ist
auch das Grundprinzip der **Kreativität**.

<file_sep>/chcko/r/bp/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from chcko.chcko.hlp import Struct

import sympy
from sympy import S, Rational as R
from sympy.abc import x


def chiven():
    b = randrange(3, 6)
    c = b + randrange(4, 9)
    d = c + randrange(3, 6)
    u = randrange(1, 4)
    v = u + randrange(1, 4)
    w = v + randrange(1, 4)
    l = w / b ** R(1, 2)
    ff = l * x ** R(1, 2)
    gg = (u - w) * (x - b) / (c - b) + w
    hh = (v - u) * (x - c) / (d - c) + u
    t = randrange(3, 9)
    g = Struct(
        f=sympy.sstr(ff),
        g=sympy.sstr(gg),
        h=sympy.sstr(hh),
        b=b,
        c=c,
        d=d,
        t=t)
    return g


def chalc(g):
    r1 = sympy.integrate(sympy.pi * S(g.f) ** 2, (x, 0, S(g.b)))
    r2 = sympy.integrate(sympy.pi * S(g.g) ** 2, (x, S(g.b), S(g.c)))
    r3 = sympy.integrate(sympy.pi * S(g.h) ** 2, (x, S(g.c), S(g.d)))
    vr = float(S(r1 + r2 + r3).n())
    s1 = sympy.integrate(2 * S(g.f), (x, 0, S(g.b)))
    s2 = sympy.integrate(2 * S(g.g), (x, S(g.b), S(g.c)))
    s3 = sympy.integrate(2 * S(g.h), (x, S(g.c), S(g.d)))
    vs = float(S((s1 + s2 + s3) * g.t).n())
    return [vs, vr]
<file_sep>/chcko/r/i/__init__.py
# -*- coding: utf-8 -*-

import random
from sympy.abc import x
from sympy import log, latex
from chcko.chcko.hlp import Struct, norm_int as chorm

jsFuncs = {'exp': 'return Math.pow(({0}),x-({1}))+({2})',
           'log': 'if (x-({0})>0) return Math.log(x-({0}))+({1})',
           'pow': 'return ({0})*Math.pow(x-({1}),({2}))+({3})'}


def chiven():
    # r,i,n,m=143,3,5,50
    N = 4
    rs = lambda r: random.sample(r, 1)[0]

    def gete():
        e = e0, e1, e2 = rs([0.2, 0.5, 2, 3]), rs(
            [-2, -1, 0, 1, 2]), rs([-2, -1, 0, 1, 2])
        ee = e0 ** (x - e1) + e2
        jse = jsFuncs['exp'].format(*e)
        return (latex(ee), jse)

    def getl():
        l = l0, l1 = rs([-2, -1, 0, 1, 2]), rs([-2, -1, 0, 1, 2])
        el = log(x - l0) + l1
        jsl = jsFuncs['log'].format(*l)
        return (latex(el), jsl)

    def getp():
        p = (p0, p1, p2, p3) = (
            rs([-2, -1, -1.0 / 2, 1.0 / 2, 1, 2]),
            rs([-2, -1, 0, 1, 2]),
            rs([-0.2, -0.5, -2, -3, 0.2, 0.5, 2, 3]),
            rs([-2, -1, 0, 1, 2]))
        ep = p0 * (x - p1) ** p2 + p3
        jsp = jsFuncs['pow'].format(*p)
        return (latex(ep), jsp)
    funcs = []
    while len(funcs) < N:
        f = rs([gete] * 100 + [getl] * 25 + [getp] * 1200)
        while True:
            nf = f()
            if nf not in funcs:
                funcs.append(nf)
                break
    order = list(range(len(funcs)))
    random.shuffle(order)
    g = Struct(funcs=funcs, order=order)
    return g


def chalc(g):
    return [o + 1 for o in g.order]
<file_sep>/chcko/r/m/__init__.py
# -*- coding: utf-8 -*-
import random
import numpy as np
from chcko.chcko.hlp import Struct, norm_int as chorm


def chiven():
    g = Struct()
    g.i = random.sample(range(2, 12), 1)[0]
    g.K1 = random.sample(range(30, 50), 1)[0] * 1000
    g.n1, g.n2 = random.sample(range(1, 20), 2)
    dK = random.sample(list(range(-50, -1)) + list(range(1, 50)), 1)[0] * 10
    g.K2 = int(g.K1 * (1.0 + g.i / 100.0) ** (g.n2 - g.n1) + dK)
    return g


def chalc(g):
    # g=Struct(i=8,K1=47000,n1=18,K2=36940,n2=15)
    res = 2 if g.K1 * (1.0 + g.i / 100.0) ** (g.n2 - g.n1) < g.K2 else 1
    return [res]
<file_sep>/chcko/r/cx/de.rst
.. raw:: html

    %path = "Mathe/Externe Links"
    %kind = chindnum["Texte"]
    %level = 0
    <!-- html -->


**Mengenlehre**

http://www.mathe-online.at/mathint/mengen/i.html


**Zahlen**

http://www.mathe-online.at/mathint/zahlen/i.html

http://members.chello.at/gut.jutta.gerhard/kurs/zahlen.htm


http://de.wikibooks.org/wiki/Mathematik_für_Schüler/_Zahlmengen


http://www.mathe-online.at/materialien/Andreas.Pester/files/ComNum/inhalte/komZahlen.html


**Algebra**


http://de.bettermarks.com/mathe-portal/fachgebiete/algebra.html

Körper:

http://www.mathe-online.at/lernpfade/lin_alg_glatz/?kapitel=1

Gruppe:

http://de.bettermarks.com/mathe-portal/fachgebiete/gruppentheorie.html

Vektoren:

http://www.mathe-online.at/mathint/vect1/i.html

Koordinatensystem:

http://www.mathe-online.at/mathint/zeich/i.html


**Analysis**

Funktion:

http://www.mathe-online.at/mathint/fun1/i.html

Koordinatensystem:

http://www.frustfrei-lernen.de/mathematik/koordinatensystem-2d-3d-abszisse-ordinate-mathematik.html

Ableitung:

http://www.mathe-online.at/mathint/diff1/i.html



<file_sep>/chcko/r/cl/de.rst
.. raw:: html

    %path = "Mathe/Stukturen/Gruppe"
    %kind = chindnum["Texte"]
    %level = 10
    <!-- html -->

*Gruppenartige algebraische Strukturen* bestehen aus einer Menge `M`
mit einer binären Verknüpfung `\circ`, kurz `(M,\circ)`.
Für alle Elemente (`\forall_{a,b\in M}`):

- `a\circ b \in M` **Abgeschlossenheit** `\rightarrow` **Magma**

- `a\circ(b\circ c) = (a\circ b)\circ c` **Assoziativgesetz** `\rightarrow` **Halbgruppe**

  - `a^n = a` **Idempotente** Halbgruppe `\rightarrow` **Verband**

- `\exists_e|e\circ a = a\circ e = a` **Neutrales Element** `\rightarrow` **Monoid**

- `\exists_\bar{a}|\bar{a}\circ a = a\circ\bar{a} = e` **Inverses Element** `\rightarrow` **Gruppe**

- `a\circ b = b\circ a` **Kommutativgesetz** `\rightarrow` kommutative oder **abelsche Gruppe**



<file_sep>/chcko/r/cc/__init__.py
# -*- coding: utf-8 -*-

import numpy as np
import random

from chcko.chcko.hlp import Struct, norm_frac as chorm
import chcko.r.u as ru


def chiven():
    g = ru.chiven()
    g.v = random.sample(range(-9, 9), 2)
    return g

#g.m=np.array([[3./13, 1./13],[4./13, -3./13]])
# g.v=np.array([-6,4])


def chalc(g):
    A = np.linalg.inv(np.array(g.m)).round()
    res = np.dot(A, np.transpose(g.v))
    return res.tolist()
<file_sep>/chcko/r/dk/en.rst
.. raw:: html

    %path = "maths/functions/exponential"
    %kind = chindnum["texts"]
    %level = 11
    <!-- html -->

.. role:: asis(raw)
    :format: html latex

Basics
------

In the **exponential function**

.. math::

    y = a^x

- `x` is the **exponent**
- `a` is the **basis**
- `y` is the **exponential function** of `x` on the basis `a`

The **exponent** tells how often *multiplication* with `a` is repeated.
`a` must be a positive real number: `a\in\mathbb{R}`.

.. admonition:: Multiplication

    Multiplication is an operation happening in the real world and we
    encode it with a number.  In the number set `\mathbb{Q}` the operation is
    part of the number: `2` means `\cdot 2`, and `1/2` mean `/2`.  `\cdot`
    stands for the multiplication operation and `/` stands for the
    *inverse operation*, the division. But the inverse operation is made part
    of the number by the inclusion of the fractions in `\mathbb{Q}`.
    So we only speak of *multiplication* and mean the application
    of the operation of `\mathbb{Q}\subset\mathbb{R}`.


If `a` is bigger than `1`, then `y` will increase (grow) with `x` *strictly monotonically*: `x_1<x_2 \Rightarrow y_1<y_2`.

.. tikz:: \begin{axis}[grid=both,axis lines=middle,xmin=-3,xmax=3,ymin=0,ymax=8, samples=50]
     \addplot[green]  {pow(2,x)} node[above]{$y=2^x$};
    \end{axis}

If `a` is smaller than `1`, then `y` will decrease (diminish) with `x` *strictly monotonically*: `x_1<x_2 \Rightarrow y_1>y_2`.

.. tikz:: \begin{axis}[grid=both,axis lines=middle,xmin=-3,xmax=3,ymin=0,ymax=8, samples=50]
     \addplot[green]  {pow(1/2,x)} node[above]{$y=(\frac{1}{2})^x$};
    \end{axis}


Discussion
----------

Let's compare the number of combinations of n bits:

.. math::

    2^n

with the growing processes, like with accruing of capital with annual compounding

.. math::

    (1+\frac{i}{100})^n

or the especially interesting natural growing

.. math::

    e^x = \lim_{n->\infty}(1+\frac{1}{n})^{nx}
      = \lim_{m->\infty}(1+\frac{x}{m})^m = (1+\frac{x}{\infty})^\infty

`e` is `Euler's Number <https://en.wikipedia.org/wiki/E_(mathematical_constant)>`_
whose importance is founded on the given relation.

The key to compare them is to understand **information** in the shape of bits as a growing process.
Every bit increases the size by `1` times what is there already.
Let's denote this aspect of the bit by `(1+1)` to emphasize that an additional `1`
is added to the one there already. The parentheses make this an operator, an element of the number set `\mathbb Q`.
`n` repeated applications of `(1+1)` produces a multitude of size

.. math::

    (1+1)^n = 2^n

Every new bit is *compounded* to the existing combinations.

The information measure for a real variable of size `C` is the
number of bits `n=\log_2 C` needed to grow `C` combinations.

.. admonition:: Which other variable to compare to?

   Instead of bits we could as well use the considered variable itself because
   that is there physically. But combinations are also physically there and the
   selection of values, which ultimately gives birth to variables, is physical,
   and the number of involved variables plays a role.  First this means that
   information is physical and secondly, considering quantum mechanics, the
   physical number of involved variables is huge and their individual
   contributions are tiny.

If we start from a *number of variables*, the *exponential function*
gives the *number of value combinations*.  If we start from a *number of
values*, the *logarithm* gives the *number of variables* needed to represent
it.

For **interest calculation** we look at an amount of money (the `1`), which is
deposited in the bank with interest `i`.  After `n` years the `1` has grown to

.. math::

    (1+i/100)^n = q^n

The *growth factor* `q` is not `2`, normally just a little above `1`.  The corresponding
"information" measure in this financial context would be the
number of years.

The essential difference with respect to bit information is that, what is added,
is a *fraction* of what is there. But then, fraction is actually just a matter
of units.

The units of living organisms are cells and the ultimate units in the real
world are the quantum particles.  Both of them are small compared to the things
around us. And with such small units one can also *compound* arbitrarily
(infinitely) often:

.. math::

    \lim_{m->\infty}(1+\frac{x}{m})^m = \lim_{n->\infty}(1+\frac{1}{n})^{nx} = e^x

In the first equality we see that, given a certain growth, varying the
*compounding steps* amounts to varying the *growth factor*. Due to the
importance of `e^x` one often moves the *growth factor* `q` in `y=q^x`
to the exponent of `e` (`y=e^{kx}`). `k=\ln q` is called the *gowth constant*.

.. admonition:: Natural compounding in the finantial world

  Actually in the financial world the real compounding takes place in very
  small steps, just that the bank forwards them to the customer in larger units
  of time.

`x` is the information in the **natural information** unit
`nat <https://en.wikipedia.org/wiki/Nat_(unit)>`_.  Basically we split up the size
of the variable to infinitely many infinitely small variables, such that
the growth factor per step is almost `1`.

<file_sep>/chcko/r/cx/en.rst
.. raw:: html

    %path = "maths/external links"
    %kind = chindnum["texts"]
    %level = 0
    <!-- html -->

**wikis**

http://en.wikipedia.org/wiki/Portal:Mathematics

http://en.wikibooks.org/wiki/Wikibooks:Mathematics_bookshelf

http://www.proofwiki.org/wiki/Main_Page

http://www.encyclopediaofmath.org/index.php/Main_Page

http://math.wikia.com/wiki/Math_Wiki

**forums and material**

http://math.stackexchange.com/

http://www.mymathforum.com/

http://mathforum.org/dr.math/

http://mathhelpboards.com/

http://www.purplemath.com/modules/index.htm

http://www.mathplanet.com/

http://www.math.com/

http://hyperphysics.phy-astr.gsu.edu/hbase/hframe.html

http://www.onlinemathlearning.com/

http://www.ask.com/question/science/mathematics

http://www.coolmath4kids.com/

http://www.coolmath.com/

http://www.mathplayground.com/

**online academies**

https://www.khanacademy.org/

http://www.cosmolearning.com/mathematics/

http://academicearth.org/online-college-courses/mathematics/

**books**

http://mathbooks.library.cornell.edu/

http://www.freebookcentre.net/SpecialCat/Free-Mathematics-Books-Download.html

http://people.math.gatech.edu/~cain/textbooks/onlinebooks.html

http://www.e-booksdirectory.com/mathematics.php

http://bib.tiera.ru/

**online math tools**

http://www.geogebra.org/cms/en/

http://www.geogebratube.org/

http://live.sympy.org/

http://octave-online.net/

http://www.wolframalpha.com/

https://www.mathway.com/

<file_sep>/chcko/r/cm/en.rst
.. raw:: html

    %path = "maths/stuctures/ring"
    %kind = chindnum["texts"]
    %level = 10
    <!-- html -->

*Ring-like algebraic structures* build on top of
group-like structures (:lnk:`r.cl`)
and consist of a set `M` with two binary
operations `+` and `\cdot` , in short `(M,+,\cdot)`.

- `(M,+)` and `(M,\cdot)` are monoids and `0\cdot a = 0` holds
  `\rightarrow` **Semiring**.

- `(M,+)` is commutative group
  `\rightarrow` **Ring**.

- In `(M,\cdot)` there are no two numbers, whose product is 0.
  Free of zero divisor `\rightarrow` **Integral domain**.

- `(M\setminus\{0\},\cdot)` is a commutative Group
  `\rightarrow` **Field**.

- `(M,\cdot)` satisfies the Jakobi Identity `a\cdot (b \cdot c) + c\cdot (a \cdot b) + b\cdot (c \cdot a) = 0`
  `\rightarrow` **Lie Ring**.

- `(M,\cdot)` is idempotent
  `\rightarrow` **Boolean Algebra**.


<file_sep>/chcko/r/a4/__init__.py
from chcko.chcko.hlp import Struct
import numpy as np
import pint
u = pint.UnitRegistry()
import random

def chiven():
    g = Struct()
    g.Vcc = random.choice(range(7,15))*u.V
    g.Vi = random.choice(range(4,g.Vcc.magnitude-2))*u.V
    g.hfe = random.choice(range(5,15))*10
    g.Vbe = random.choice([0.3,0.7])*u.V
    g.Rc = (random.choice(range(100))+100)*10*u.ohm
    Vo1 = random.choice(range(2,g.Vi.magnitude-1))*u.V
    ReRL = g.Rc/(g.Vcc/Vo1-1)
    g.RL = g.Re = 2*round(ReRL.magnitude)*u.ohm
    return g
def chalc(g):
    #g = chiven()
    Vo0 = g.RL/(g.RL+g.Rc)*g.Vcc
    Vo1 = g.Vcc*(1-g.Rc/(g.Rc+1/(1/g.Re+1/g.RL)))
    g.Icmax = Vo1/g.Re
    Ibmax = g.Icmax/g.hfe
    Rb = (g.Vi-Vo1-g.Vbe)/Ibmax
    res = [x.to('V').magnitude for x in [Vo0,Vo1]] + [Rb.to('kΩ').magnitude]
    return res
chames = [r'\(V_0/V=\)', r'\(V_1/V=\)', r'\(R_b/kΩ=\)']
P = lambda x: "{:~P}".format(x)

<file_sep>/chcko/r/bw/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from chcko.chcko.hlp import Struct
from datetime import datetime, timedelta


def chiven():
    g = Struct()
    g.K0 = randrange(20, 100) * 1000
    g.d1 = datetime.now() - timedelta(days=randrange(300)) - \
        timedelta(days=365)
    g.d2 = datetime.now() + timedelta(days=randrange(300)) + \
        timedelta(days=365)
    g.i = 1.0 + 1.0 * randrange(20) / 10
    return g


def chalc(g):
    K0 = g.K0
    i = g.i
    d1 = g.d1
    d2 = g.d2
    d1d = 30 * (12 - d1.month) + ((30 - d1.day) if d1.day <= 30 else 0)
    d2d = 30 * (d2.month - 1) + d2.day
    n = d2.year - d1.year - 1
    q1 = 1 + i * d1d / 360.0 / 100
    q2 = 1 + i * d2d / 360.0 / 100
    q = 1 + i / 100.0
    Kn1 = K0 * q1 * q ** n * q2
    nf = n + d1d / 360.0 + d2d / 360.0
    Kn2 = K0 * q ** nf
    dKn = Kn1 - Kn2
    return [Kn1, dKn]
<file_sep>/chcko/r/ba/de.html
%path = "Mathe/Folgen und Reihen/arithmetische u. geometrische"
%kind = chindnum["Übungen"]
%level = 10

Gegeben ist die Folge {{g_fn[chiven.rr](chiven.a1,chiven.q,1)}},
{{g_fn[chiven.rr](chiven.a1,chiven.q,2)}}, {{g_fn[chiven.rr](chiven.a1,chiven.q,3)}},...<br>
Gesucht ist das {{chiven.n}}te Glied
\(a_{ {{chiven.n}} }\) =
%chq(0)
<br>
sowie die Summe der ersten {{chiven.N}} Glieder
\(\sum_{k=1}^{ {{chiven.N}} } a_k\) =
%chq(1)

<file_sep>/chcko/r/ch/en.rst
.. raw:: html

    %path = "maths/sequences and series"
    %kind = chindnum["texts"]
    %level = 10
    <!-- html -->


Sequences and Series
--------------------

A **Sequence** is a function of natural numbers (positive integers).

The natural number is used to refer to the position of an element (term) of the sequence.
It is called index.

- `a_1` is the first element of the sequence
- `a_2` is the second element
- ...
- `a_n` is the n-th element

If we sum up the first n elements of a sequence,
then we get the n-th element of the sum sequence or **series**.

The use of *function* says:
If I know which position, then I know the number at that position.

Many sequences have a regularity that allows to descibe them in a much shorter way
(short description = low complexity). Here are the most important ones

Arithmetic Sequence
...................

In the arithmetic sequence one element follows from the previous one by adding a contant

`a_{n+1} = a_n + d`.

This is called **recursive** description of the arithmetic sequence.

To get to the n-ten element from the first one, we repeat adding with d for n-1 times:

`a_n = a_1 + (n-1) d`

This is the **term description**:

.. admonition:: note

    In many programming languages one starts with 0, because then you can do
    `nd` instead of `(n-1)d`.

To recognize a sequence to be arithmetic you check whether the differences
between successive numbers stay the same.

Arithmetic Series
.................

If you look at the sum of the first n elements, you can see a regularity,
which is always used to make calculations simpler.

In the above term description you can notice, that starting from the beginning
each element is larger by d, and starting from the end (nth) backward each element
is smaller by d. These operations cancel and therefore we can calculate Count/2 times
sum of first plus nth element.

`\sum_{k=1}^{n} a_k = \frac{n(a_1+a_n)}{2}`

Specifically we have `1+2+...n=\frac{(n+1)n}{2}`.

Geometric Sequence
..................

In the geometric sequence one element follows from the previous one by
multiplying a constant

`a_{n+1} = a_n \cdot q`.

This is the **recursive** description of the geometric sequence.

To get to the nth element starting from the first one, we repeat multiplying by q for n-1 times:

`a_n = a_1 q^{n-1}`

This is the **term description** of the geometric Sequence.

To recognize a given sequence as geometric, you check whether the quotient of successive elements
stays the same.

Geometric Series
................

In

.. math::

    \begin{matrix}
    1+&q+q^2+...+q^{n-1}&=&S_n\\
      &q+q^2+...+q^n&=&q S_n\\
    \end{matrix}

you see many equal terms. By subtraction you get

`\sum_{k=1}^{n} q^{k-1} = 1 + q + ... + q^{n-1} = \frac{q^n-1}{q-1}=\frac{1-q^n}{1-q}`

<file_sep>/chcko/r/k/__init__.py
# -*- coding: utf-8 -*-
import random
import numpy as np
from chcko.chcko.hlp import Struct


def chiven():
    r = sorted(random.sample(range(-9, -1), 2) + random.sample(range(1, 9), 2))
    c = [-1, +r[0] + r[1] + r[2] + r[3],  # x**4,x**3
         -r[0] * r[1] - r[0] * r[2] - r[0] * r[3] - r[1] *
         r[2] - r[1] * r[3] - r[2] * r[3],  # x**2
         +r[0] * r[1] * r[2] + r[0] * r[1] * r[3] +
         r[0] * r[2] * r[3] + r[1] * r[2] * r[3],  # x
         -r[0] * r[1] * r[2] * r[3]]
    g = Struct(r=r, c=c)
    return g


def chalc(g):
    p = np.poly1d(g.c)
    p_i = np.polyint(p)
    I = +p_i(g.r[1]) - p_i(g.r[0]) - p_i(g.r[2]) + \
        p_i(g.r[1]) + p_i(g.r[3]) - p_i(g.r[2])
    return [I]
<file_sep>/Makefile
.PHONY: check html dist up

check:
	restview --long-description --strict

html:
	cd chcko/r
	doit -kd. html
	doit -kd. initdb

dist: html
	sudo python setup.py bdist_wheel

up:
	twine upload dist/`ls dist -rt | tail -1`



<file_sep>/chcko/r/bv/__init__.py
# -*- coding: utf-8 -*-
from random import sample
from chcko.chcko.hlp import Struct, norm_list, norm_frac

import numpy as np
from numpy.linalg import det


def chiven():
    z = zip("ABC", zip(sample(range(-9, 10), 3), sample(range(-9, 10), 3)))
    g = Struct(z)
    return g


def chalc(g):
    D = (np.array(g.C) + np.array(g.A) - np.array(g.B)).tolist()
    A = int(
        abs(det(np.vstack([np.array(g.C) - np.array(g.B), np.array(g.A) - np.array(g.B)]))))
    return [','.join([str(dd) for dd in D]), str(A)]

chorm = lambda v: norm_list(v, norm_frac)
<file_sep>/chcko/r/cg/de.rst
.. raw:: html

    %path = "Mathe/Vektoren/Transformation und Inverse"
    %kind = chindnum["Texte"]
    %level = 11
    <!-- html -->


Koordinatentransformation und Inverse Matrix
============================================

Nicht immer sind die Basisvektoren unabhängig, d.h.  orthogonal zueinander.

Wenn man etwa die Zutaten von einer Auswahl von Kuchen als Vektorraum auffasst
(*Zutatenvektorraum*), dann ist jeder Kuchen ein Vektor, d.h. eine unabhängige
Auswahl aus mehreren Variablen (Quantitäten der Zutaten, 0 falls nicht
verwendet).

Die Zutaten kann man als orthogonal zueinander ansehen. Der Kontext macht
einen genaueren Vergleich nicht notwendit.
*Das skalare Produkt ist 0.*

Die Kuchen wollen wir aber genauer vergleichen und zwar über deren Zutaten.
Dann werden etwa Kuchen A und Kuchen B sicher gleiche Zutaten haben.
Die Einheitsvektoren im *Kuchenvektorraum* sind nicht orthogonal zueinander,
wenn man genauer hinschaut, was man aber nicht tun muss.
*Das skalare Produkt ist nicht 0.*

Ein Vektor im Kuchenvektorraum (Wieviel von jeder Sorte Kuchen?) kann auf den Vektorraum der Zutaten
transformiert werden, indem man ihn mit einer Matrix multipliziert.
Jede Spalte in dieser Matrix stellt einen Kuchen dar.

Was man bei Matrizen und Vektoren macht, ist eine Positionskodierung. Die Position einer Zahl
bestimmt, was sie bedeutet. Das macht man auch im Zahlensystem so (Einer, Zehner, Hunderter,...).

In diesem Beispiel mit den Kuchen und den Zutaten sind die Anzahl der Variablen (=Dimension)
in den zwei Vektorräumen nicht notwendigerweise gleich. Die Dimensionen können anders sein,
etwa 10 Zutaten und 3 Kuchensorten. Die Transformationsmatrix ist dann 10x3 (10 Zeilen, 3 Spalten).
Eine solche `m\times n` Matrix mit `m\not = n` kann man nicht invertieren,
d.h. man kann nicht aus einem Zutatenvektor auf die Kuchensorten (Kuchenvektor) schließen.
Oder anders ausgedrückt: Es gibt nicht für jede Kombination von Zutaten eine Kombination
(*Linearkombination*) von Kuchen, die genau diese Zutatenmengen brauchen.

Fixiert man die Anzahl der Kuchen in einer kleinen Sortenauswahl
wird weniger Information festgelegt, d.h. es werden weniger Auswahlentscheidungen getroffen,
als im Zutatenraum, der im Beispiel als größer angenommen wird.

.. admonition:: Pseudoinverse

    Man kann sie aber pseudo-invertieren (Moore-Penrose Pseudoinverse).  Im
    Beispiel erzeugt letztere aus den Zutaten einen Kuchensortenvektor der
    minimal Zutatenreste zurück lässt (Methode der kleinsten Quadrate) bzw. die
    Zutaten bestmöglichst ausnützt (maximale Entropie).

Wenn man von einem Vektorraum in einen mit gleicher Dimension transformiert,
dann kann man wieder auf die urspünglichen Vektoren kommen,
indem man mit der *inversen Matrix* multipliziert.

Damit die Inverse existiert, muss zusätzlich zur quadratischen Form jede
Spalte/Zeile *linear unabhängig* von den anderen sein, sonst befindet man sich
effektiv in einer kleineren Matrix (*Rang einer Matrix*).  Im Kuchenbeispiel
bedeutet das, dass jede Kuchensorte eine andere Zutatenkombination haben muss,
damit man sie von den anderen unterscheiden kann und damit mit ihr zusätzliche
Information kodiert werden kann.

.. admonition:: Lineare Unabhängigkeit

    Quadratische Matrizen können invertiert werden,
    wenn eine Spalte (oder Zeile) sich nicht aus den anderen durch Linearkombination
    ergibt. Der Rang der Matrix ist gleich seiner Dimension.

Die Inverse einer quadratischen Matrix kann man allgemein berechnen indem man:

- das `ij` Kreuz weglässt und Determinante berechnet = Minor `M_{ij}`
- das Vorzeichen ändert, falls `i+j` ungerade ist
- dann transponiert, d.h. an der Diagonale spiegelt
  (unten:`ij` bei `A` und `ji` bei `M`)
- alles durch die Determinante teilt

Kurz

.. math::

    (A^{-1})_{ij} = \frac{1}{det(A)}(-1)^{i+j} M_{ji}


`\frac{1}{det(A)}` schreibt man oft vor der Matrix. Man kann diesen Wert aber
auch mit jeder Zahl in der Matrix multiplizieren.

Für eine *2x2 Matrix* ist `M_{ij}` die diagonal gegenüberliegende Zahl.
Wegen des Transponierens bleibt die Zahl links unten und rechts oben (Nebendiagonale),
aber das Vorzeichen ändert sich.
Auf der Hauptdiagonalen werden die Zahlen vertauscht und da `i+j` gerade ist,
bleibt das Vorzeichen.

- Hauptdiagonale `\rightarrow` Vorzeichen bleibt
- Nebendiagonale `\rightarrow` Position bleibt

<file_sep>/chcko/r/a/__init__.py
import random
import math as m
from chcko.chcko.hlp import Struct
def angle_deg(i, g):
    d = dict(zip('abc', ([g.a, g.b, g.c]*2)[i:]))
    return eval('180*acos((a*a+b*b-c*c)/2/a/b)/pi', {**d,'acos':m.acos,'pi':m.pi})
def chiven():
    random.seed()
    a, b = random.sample(range(1, 10), 2)
    c = random.randrange(max(a - b + 1, b - a + 1), a + b)
    return Struct(a=a, b=b, c=c)
def chalc(g):
    return [angle_deg(i, g) for i in range(3)]
chames = [r'\(\alpha=\)', r'\(\beta=\)', r'\(\gamma=\)']
<file_sep>/chcko/r/ct/de.rst
.. raw:: html

    %path = "Mathe/Richtung"
    %kind = chindnum["Texte"]
    %level = 11
    <!-- html -->

Die Variablen, mit denen man es normalerweise zu tun hat,
sind Ausdehnungen (Größen, Teilmengen, Differenzen) und nicht Punkte.
3m meint alle Punkte von von 0 bis 3m.

Zwei unterschiedliche Mengen, für die alle Kombinationen vorkommen,
kann man als orthogonal zueinander ansehen.
Der Winkel zwischen ihnen ist `\frac{\pi}{2}`.
Sie spannen die größtmögliche Kombinationsmenge (Fläche) auf.
Vektorprodukt maximal. Skalares Produkt 0.

Ein zweidimensionaler Vektor `\vec{v}` und eben auch `z\in\mathbb{C}` bezeichnet
eine solche Ausdehnung. Die eingeschlossene Fläche ist
`\vec{v_1}\times\vec{v_2}` oder `Im(z_1\bar{z_2})`.

`z_1\bar{z_2}` hat das Skalarprodukt im Realteil und das Vektorprodukt im Imaginärteil.

Größen, die in die gleiche Richtungen zeigen, kann man addieren.  Ungleiche
Richtungen kann man komponentenweise addieren.
`\frac{\vec{v_1}\vec{v_2}}{|\vec{v_1}|}=\vec{v_1}_0\vec{v_2}` ist die
Komponente von `\vec{v_2}`, die in Richtung `\vec{v_1}` addiert werden kann.
`\frac{z_1\bar{z_2}}{|z_1|}` ist die komplexe Zahl mit Realteil addierbar in
Richtung `z_1` und Imaginäteil orthogonal zu `z_1`, multiplizierbar um die
aufgespannte Fläche zu erhalten. Besser man rechnet jedoch normal `z_1+z_2`,
d.h. mit den durch das Koordinatensystem gegebenen Komponenten.

Der Winkel ergibt sich aus dem Verhältnis der aufgespannten Fläche zur maximalen Fläche
`\angle(\vec{v_1},\vec{v_2})=\arcsin\frac{|\vec{v_1}\times \vec{v_2}|}{|\vec{v_1}||\vec{v_2}|}`
oder aus dem Verhältnis der addierbaren Komponente zur gesamter Länge
`\angle(\vec{v_1},\vec{v_2})=\arccos\frac{\vec{v_1}\vec{v_2}}{|\vec{v_1}||\vec{v_2}|}`
und im Komplexen zusammen
`\angle(z_1,z_2)=\arg(\frac{z_1\bar{z_2}}{|z_2||z_2|})=\arg{z_1\bar{z_2}}`.

Ein anderes Wort für Richtung ist Phase, das wohl von dem umgangssprachlich
vorbelegten Wort Richtung etwas ins Abstraktere ablenken soll. Essentiell ist
der Vergleich zweier Größen bezüglich addierbarer Komponenten. Dazu werden
Variablen die keine Richtung darstellen, aber eben Einfluss auf Addierbarkeit
haben, auf einen Winkel umgerechnet, der dann Phase heißt.  Beispiel:
Der Zeitpunkt `t` bei Schwingungen wird `\varphi=\frac{2\pi}{T}t` oder die
kombinierte Zeit-, Raum-Position bei Wellen wird
`\varphi=\frac{2\pi}{\lambda}x-\frac{2\pi}{T}t`.  `Ae^{i\varphi}` gibt dann die
momentan addierbare Amplitude wieder.


<file_sep>/chcko/r/bn/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from math import log
from chcko.chcko.hlp import Struct


def chiven():
    g = Struct()
    g.Kn = randrange(1000, 2000)
    g.K0 = randrange(20, 999)
    g.i = randrange(2, 9)
    return g


def chalc(g):
    res = log(g.Kn / g.K0) / log(1.0 + g.i / 100.0)
    return [res]
<file_sep>/chcko/r/a0/__init__.py

# # for a problem uncomment (non-problem texts need no code in __init__.py)
# from chcko.chcko.hlp import Struct
# # randomize numbers using e.g. sample and randrange
# import random
# def chiven():
#     g = Struct()
#     # fill g
#     return g
# def chalc(g):
#     res = []
#     # fill res
#     return res
# # #remove if default norm_rounded works fine
# # def chorm(answers):
# #     return norm_rounded(answers)
# # #remove if default equal_eq works fine
# # def chequal(a, r):
# #     return equal_eq(a, r)
<file_sep>/chcko/r/a2/en.html

    %path = "maths/numbers/NZQR"
    %kind = 0
    %level = 9
    <!-- html -->

Given two integers \(a\) and \(b\),
with
\(a {{'<>'[chiven.a.is_positive]}} 0\) and \(b={{chiven.rep[1].replace('*','')}}\),
which expression is always a natural numbers?
<br>
%include('r/a2/x_')
<file_sep>/chcko/r/bz/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from math import pi, atan
from chcko.chcko.hlp import Struct


def chiven():
    g = Struct()
    g.l = randrange(21, 100)
    g.h = randrange(5, int(g.l / 2))
    return g


def chalc(g):
    percentage = 100 * g.h / (g.l * g.l - g.h * g.h) ** 0.5
    angle = 180 * atan(g.h / (g.l * g.l - g.h * g.h) ** 0.5) / pi
    return [percentage, angle]
<file_sep>/chcko/r/bb/__init__.py
# -*- coding: utf-8 -*-

import numpy as np
import random
from itertools import permutations
from chcko.chcko.hlp import Struct, norm_frac

pyt = [[3, 4], [5, 12], [6, 8], [4, 3], [12, 5],
       [8, 6], [-3, 4], [-5, 12], [-6, 8],
       [-4, 3], [-12, 5], [-8, 6], [3, -4],
       [5, -12], [6, -8], [4, -3], [12, -5], [8, -6]]
ipyt = 0
per = list(permutations([0, 1, 2]))


def chiven():
    global pyt, ipyt
    A = np.array(random.sample(range(-9, 10), 2))
    ipyt = (ipyt + 1) % len(pyt)
    d1 = np.array(pyt[ipyt])
    d2 = np.array([d1[1], -d1[0]])
    if random.random() > 0.5:
        d2 = -d2
    B = A + d1
    C = A + d2
    p = [A.tolist(), B.tolist(), C.tolist()]
    random.shuffle(p)
    g = Struct(p=p)
    return g


def chalc(g):
    for i in per:
        a = np.array(g.p[i[1]]) - np.array(g.p[i[0]])
        b = np.array(g.p[i[2]]) - np.array(g.p[i[0]])
        if np.dot(a, b) == 0:
            break
    F = abs(np.linalg.det([a, b])) / 2
    return ["ABC"[i[0]], F]


def chorm(answers):
    return [answers[0].upper(), norm_frac(answers[1])]
<file_sep>/chcko/r/bm/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from chcko.chcko.hlp import Struct, norm_expr, norm_rounded, equal_0 as equal
import sympy
from sympy import S, Rational as R, latex
from sympy.abc import x


def chiven():
    xp0 = randrange(7, 10)
    pmax = randrange(7, 10)
    Ep = R(-pmax, xp0) * x + pmax
    E = sympy.integrate(Ep, x)
    b = randrange(2, xp0 - 2)
    cmax = int(Ep.subs(x, b).n())
    c = randrange(1, cmax)
    a = R(randrange(1, pmax - c), b * b)
    Kp = a * (x - b) ** 2 + c
    Gp = Ep - Kp
    rG = [r.n() for r in sympy.roots(Gp) if r > 0][0]
    G = sympy.integrate(Gp, x)
    mG = G.subs(x, rG)
    Ko = int(mG - 1) / 2
    #K = sympy.integrate(Kp,x)+Ko
    #G = E.n()-K.n()
    #rts = sorted([r.n() for r in sympy.roots(G) if r > 0])
    g = Struct(pmax=pmax, xp0=xp0, Ko=Ko, Kp=sympy.sstr(Kp))
    return g


def chorm(a):
    res = [norm_expr(aa) for aa in a[:5]] + norm_rounded(a[5:], 2)
    return res


def chalc(g):
    Kp = S(g.Kp)
    Ep = R(-g.pmax, g.xp0) * x + g.pmax
    E = sympy.integrate(Ep, x)
    K = sympy.integrate(Kp, x) + S(g.Ko)
    Gp = Ep - Kp
    rG = [r.n() for r in sympy.roots(Gp) if r > 0][0]
    G = E - K
    mG = G.subs(x, rG)
    kk = sympy.Wild('kk')
    dd = sympy.Wild('dd')
    kd = Ep.match(kk * x + dd)
    p = kd[kk] * x / 2 + kd[dd]
    mp = p.subs(x, rG)
    el = S(1 + kd[dd] / (kd[kk] * x / 2))
    return [
        sympy.sstr(Ep),
        sympy.sstr(E),
        sympy.sstr(K),
        sympy.sstr(p),
        sympy.sstr(el),
        rG,
        mp]

<file_sep>/chcko/r/cn/de.rst
.. raw:: html

    %path = "Mathe/Zahlen/Darstellung"
    %kind = chindnum["Texte"]
    %level = 9
    <!-- html -->

Eine Anzahl ist etwas reales und unabhängig von deren Darstellung.

Hier werden nur `Stellenwertsysteme <http://de.wikipedia.org/wiki/Stellenwertsystem>`_
diskutiert, aber es gibt andere Systeme. Siehe
`Wikipedia Artikel <http://de.wikipedia.org/wiki/Zahlensystem>`_.

Darstellung von Zahlen
======================

Man kann nicht für jede Anzahl ein individuelles Zeichen machen.  Stattdessen
verwenden wir Zeichen bis zu einer bestimmten Anzahl und, sobald diese erreicht
ist, zählen wir Häufchen von dieser Anzahl.

.. admonition:: Hinweis

    Ein Zahlensystem kann man mit einem Buchstaben oder Lautsystem vergleichen.
    In einer Sprachen werden Laute kombiniert und so eine Vielheit erzeugt, eben Wörter.
    Diese werden dann zu realen Dingen abgebildet.
    Mit Zahlen ist es gleich. Ziffern werden kombiniert und dann zur Anzahl abgebildet.

Das Dezimalsystem (Zehnsersystem)
---------------------------------

- Für eine Anzahl unter zehn gibt es ein eigenes Zeichen: 1, 2, 3, 4, 5, 6, 7, 8, 9.
- Für "kein" gibt es die **0**. Zusammen mit der 0 gibt es im Zehnersystem 10 Zeichen.
- Für eine Anzahl Zehn und darüber machen wir Zehnerhäufchen und zählt diese separat.

Positionscodierung:

    Statt etwa 3 Zehner und 4 Einer zu schreiben, schreiben wir die 3 an eine Stelle für die Zehner
    und 4 an die Stelle für die Einer: 34.
    Das kann man Positionscodierung nennen: Über die Position identifiziert man, was man meint.

    302 heißt 3 Zehnerhäufchen von Zehnerhäufchen (Hundert), 0 (keine) Zehner und 2 Einer.

Wertigkeit:
    Die Wertigkeit der Stellen (=Positionen) ist von rechts nach links aufwärts:

    ...  10³=1000 10²=100 10¹=10 10⁰=1

    Das sind alles Potenzen von 10.
    10 ist die **Basis** des Dezimalsystems.

Brüche:
    So wie ein zehnfaches Häufchen eine Stelle hat, so wird auch dem zehnten Teil eine
    Stelle nach dem Komma gegeben.

    ,1/10¹=1/10  1/10²=1/100  1/10³=1/1000 ...

Das Dualsystem (Binärsystem, Zweiersystem)
------------------------------------------

Im Dualsystem wird eine Anzahl von 2 zu einem eigenen Häufchen.

Zusammen mit der 0 gibt es im Binärsystem 2 Zeichen, die dann bedeuten: **Da oder Nicht Da**

Die Wertigkeit der Stellen ist von rechts nach links aufwärts:

    ...  2⁴=16 2³=8 2²=4 2¹=2 2⁰=1 , `2^{-1}` `2^{-2}` ...

Beispiel:

    1011₂ = 11₁₀

Das Dualsystem ist sehr wichtig, da es in Computern verwendet wird und weil 2 die kleinste Anzahl ist,
bei der man noch auswählen kann, d.h. Information codieren kann.

Das Hexadezimalsystem (Sechszehnersystem)
-----------------------------------------

Hier macht man jeweils 16 zu einem neuen Häufchen.

Zusammen mit der 0 gibt es im Hexadezimalsystem 16 unterschiedliche Zeichen:

    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

Dabei bedeuten A=10, B=11, C=12, D=13, E=14, F=15.

Die Wertigkeit der Stellen sind von rechts aufwärts:

    ... 16⁴=65536 16³=4096 16²=256 16¹=16 16⁰=1 ,  `16^{-1}` `16^{-2}` ...

Da 2⁴=16 braucht man für eine Stelle im Hexadezimalsystem immer 4 Stellen im Dualsystem.
Da das 2er System wichtig ist, macht diese Eigenschaft auch das Hexadezimalsystem und alle
Zahlensystem, die Potenzen von 2 sind wichtig,
z.B. Basis 8 (octal), 64 (base64), 128(ASCII) und 256 (ANSI).

Duodezimalsystem
-----------------

Zwölf hat viele Teiler: 2, 3, 4, 6
Das erlaubt eine einfache Darstellung von Brüchen mit diesem Nenner.

Aber wie beim Dezimalsystem (1/3 = 0.333...)
gibt es auch im Duodezimalsystem Brüche, die periodische sind (1/5 = 0.2497 2497...).

<file_sep>/chcko/r/cu/en.rst
.. raw:: html

    %path = "maths/functions/integral of 1÷z"
    %kind = chindnum["texts"]
    %level = 12
    <!-- html -->

From real calculus we know, that
`\frac{dy}{dx}=\frac{d\,e^x}{dx}=e^x=y`, and therefore for the inverse `\ln`
`\frac{dx}{dy}=\frac{d\,\ln y}{dy}=\frac{1}{y}` for `y>0`.  For the antiderivative
of `\frac{1}{y}` we can include negative `y`, if we take the absolute value:
`\int\frac{1}{y}dy=ln|y|+C`.  This follows from the symmetry of `\frac{1}{y}`.
At 0 there is a singularity, i.e. one cannot integrate over it.

In `\mathbb{C}` we have `e^z=e^{x+iy}=e^xe^{iy}`,
i.e. the real part becomes the absolute value `e^x` and the imaginary part becomes the argument.
That is the reason for the period `2\pi i` along the imaginary axis.
The antiderivative of `\frac{1}{z}` is the inverse of `e^z`,
which means that the absolute value becomes the real part `ln|z|` and the argument
becomes the imaginary part.

`\int \frac{1}{z}dz=ln|z|+i\arg(z)+C`

In `\mathbb{C}` one can integrate around the singularity:

.. math::

    \oint_{|z|=1}\frac{1}{z}dz =
    (\ln|z| + i\arg z)\bigr|_{\arg z=0,\,|z|=1}^{\arg z=2\pi,\,|z|=1} = 2\pi i

This is the precursor of the residue theorem.

<file_sep>/chcko/r/ba/en.html
%path = "maths/sequences and series/arithmetic and geometric"
%kind = chindnum["problems"]
%level = 10

In the sequence {{g_fn[chiven.rr](chiven.a1,chiven.q,1)}},
{{g_fn[chiven.rr](chiven.a1,chiven.q,2)}}, {{g_fn[chiven.rr](chiven.a1,chiven.q,3)}},...<br>
what is the {{chiven.n}}th term
\(a_{ {{chiven.n}} }\) =
%chq(0)
<br>
and what is the sum of the first {{chiven.N}} terms
\(\sum_{k=1}^{ {{chiven.N}} } a_k\) =
%chq(1)

<file_sep>/chcko/r/dh/en.rst
.. raw:: html

    %path = "physics/mechanics/forces"
    %kind = chindnum["examples"]
    %level = 10 #in school years
    <!-- html -->

.. role:: asis(raw)
    :format: html latex

Structure Analysis Problem solved with Python
=============================================

This pin jointed truss is the initial example taken from `akabaila`_

.. _akabaila: http://akabaila.pcug.org.au/StructuralAnalysis.pdf

.. tikz:: \coordinate (A) at (0,0) (A) node [below]{0};
   \coordinate (B) at (0,3) (B) node [above]{1};
   \coordinate (C) at (4,0) (C) node [below]{2};
   \coordinate (D) at (4,3) (D) node [above]{3};
   \coordinate (E) at (8,0) (E) node [below]{4};
   \coordinate (F) at (8,3) (F) node [above]{5};
   \coordinate (G) at (12,0) (G) node [below]{6};
   \coordinate (H) at (12,3) (H) node [above]{7};
   \tikzset{-};
   \draw[black,very thick] (A) -- (B) node [midway,left]{0};
   \draw[black,very thick] (A) -- (C) node [midway,below]{3};
   \draw[black,very thick] (B) -- (C) node [midway,left,below]{2};
   \draw[black,very thick] (B) -- (D) node [midway,below]{1};
   \draw[black,very thick] (C) -- (D) node [midway,left]{4};
   \draw[black,very thick] (C) -- (E) node [midway,below]{7};
   \draw[black,very thick] (D) -- (E) node [midway,left,below]{6};
   \draw[black,very thick] (D) -- (F) node [midway,below]{5};
   \draw[black,very thick] (E) -- (F) node [midway,left]{8};
   \draw[black,very thick] (E) -- (G) node [midway,below]{10};
   \draw[black,very thick] (E) -- (H) node [midway,right,below]{11};
   \draw[black,very thick] (F) -- (H) node [midway,below]{9};
   \draw[black,very thick]  (G) -- (H) node [midway,right]{12};
   \draw[black,thin]  (0,0) -- (1,-1) -- (-1,-1) -- (0,0);
   \draw[black,thin]  (12,0) -- (13,-1) -- (11,-1) -- (12,0);
   \tikzset{->};
   \draw[black,thin]  (4,-1) -- (4,-2) node [midway,right]{100kN};
   \draw[black,thin]  (8,-1) -- (8,-2) node [midway,right]{150kN};
   \tikzset{<->};
   \draw[black,very thin]  (0,4) -- (12,4) node [midway,above]{3x8m};
   \draw[black,very thin]  (13,0) -- (13,3) node [midway,right]{6m};

It can be analysed using force and moment vectors,
because resulting linear equations are neither underdetermined
nor overdetermined, but determined.
The truss is said to be *statically determinate*.

**We want to find the forces along the members.**

To find all the forces along the members we use:

- no revolution: all moments must be matched by reacting moments
- no translation: all forces in all nodes add to zero.

We will solve this here using ``Python`` with ``numpy`` and ``scipy``
and more precisely we will do with these functions:

.. code-block:: python
    :linenos:

    from numpy import dot, cross, array, allclose, transpose, finfo, double;
    from scipy.linalg import norm, solve;
    unit = lambda v: v/norm(v)
    R90 = array([[0, 1], [-1, 0]]) # rotate 90 degrees
    V = array
    eps = finfo(double).eps

First we need to describe the problem world, i.e. we need to find the variables.
By variable I mean the real thing here. A variable consists of values.
When using a value of a variable, then we do this via reference,
more precisely via index into the list of values representing the variable.

The following describes the system. I use capital letters for variables and
small letters for references to values of the variables. The names are short,
one letter if possible. I take the first letter of the english word. N is Nodes,
E is Edges, F is Forces, S is Support nodes. n, e, f and s reference values of these
variables. A value of Nodes consists of x and y, which reference the external variables
X and Y (the values of). By external I mean that they are not specified in the code.

.. code-block:: python
    :linenos:

    #nodes = x, y
    N = [V((a*8,b*6)) for a,b in [(0,0),(0,1),(1,0),(1,1),(2,0),(2,1),(3,0),(3,1)]];
    #edge = (n1,n2), n_i = indix into N
    E = [(0, 1), (1, 3), (1, 2), (0, 2), (2, 3), (3, 5), (3, 4),
            (2, 4), (4, 5), (5,7), (4, 6), (4, 7), (6, 7)]
    #external forces = index into N for node of application, vector
    F = [(2,V((0,-100))), (4,V((0,-150)))]
    #support points = indices into N
    S = [0,6];

Now let's find the forces along the edges.

1. No revolution.

   We need to make the moment created around one support point zero by constructing a force
   at the other support point. If there were more than one other support point for an axis,
   the system would be overdetermined, which we don't handle here.

.. code-block:: python
    :linenos:

    def react_to_mp_at_q(mp,q):
        """p != q are any nodes.
        m stands for moment. mp is the moment around node p.
        """
        dp=N[q]-N[mp[0]]
        norm_dp = norm(dp)
        if norm_dp == 0:
            return V((0,0))
        ndp = dp/norm_dp
        fq = mp[1]*dot(R90,ndp)/norm_dp
        return -fq

2. No translation

   We distribute the forces to a node to those edges not having a
   force associated yet.  In our 2D case we need two such edges. One is OK, if the
   force is exactly in that direction.

   .. admonition:: shortcoming
       For more other edges, I take one edge, if it is in the direction of the
       force and ignore the others.  This is physically not correct, but the
       method applied here is not for overdetermined systems.

   The force placed on an edge via this distribution will be forwarded to the
   other node, but there the direction must be changed: An edge under tension will
   pull from both nodes and a contracted edge will push into both nodes.

.. code-block:: python
    :linenos:

    def distribute(f,es,q):#f = sum of forces on edges es to node q
        ies = [i for i in range(len(E)) if q in E[i]]
        mat = []
        eo = []#edge, other node
        for e in ies:
            if e not in es:
                #E[e]
                t = [tt for tt in E[e] if tt==q][0]#this
                o = [tt for tt in E[e] if tt!=q][0]#other
                d0 = unit(N[o]-N[t])
                mat.append(d0)
                eo.append((e,o))
        A = transpose(array(mat))
        dim = len(f)
        if len(eo)==dim:
            r = solve(A,f)
            for i in range(len(r)):
                ff = r[i]*mat[i]
                yield ff, eo[i]#even if ff==0
        elif len(eo) > dim:
            for i,v in enumerate(mat):
                angle = dot(v,f)/norm(v)/norm(f)
                if abs(angle) < eps or abs(angle+1) < 4 * eps: #same direction
                    yield f,eo[i]
                    return
            raise ValueError('node %i overdetermined'%q)
        else:
            if allclose(unit(f),mat[0]):
                yield f, eo[0]
            else:
                raise ValueError('node %i underdetermined'%q)

The above ``distribute`` needs the edges along which forces come into the node.
We keep track of the edges with forces in a ``{node, [(edge,force)..]}`` dictionary.
Initially this is empty.  We add the external forces and the forces due to the moments.
Then we distribute forces in unbalanced nodes.

.. code-block:: python
    :linenos:

    def no_revolution():
        EF = dict([(p,[]) for p in range(len(N))])
        for p,ff in F:
            EF[p].append(([],ff))
        for i in range(len(S)):
            for j in range(len(S)):
                if j != i:
                    p = S[i]
                    q = S[j]
                    mp = (p,sum([cross(ff[1],(N[ff[0]]-N[p])) for ff in F]))
                    fq = react_to_mp_at_q(mp,q)
                    EF[q].append(([],fq))
        return EF

    def no_translation(EF):
        _sum = lambda tt: [reduce(lambda x,y:x+y,t) for t in zip(*tt)]
        unbalanced = lambda:[(i,v) for i,v in [(i,_sum(EF[i])) for i in EF]
                        if v and not allclose(norm(v[1]),0)]
        u = unbalanced()
        while len(u)>0:
            q,(es,f) = u[0]
            dist=list(distribute(f,es,q))
            for ff,eo in dist:
                EF[q].append(([eo[0]],-ff)) #q is this node of edge eo[0]
                EF[eo[1]].append(([eo[0]],ff)) #eo[1] is the other node of edge eo[0]
            u = unbalanced()
        return EF

    def format_ef(EF):
        from itertools import chain
        from pprint import pformat
        e_f = list(chain.from_iterable([[(tuple(e),norm(f)) for e,f in EF[i]] for i in EF]))
        e_f = list([(e[0],round(f,2)) for e,f in set(e_f) if e])
        e_f.sort()
        return pformat(e_f)

    EF = no_revolution()
    EF = no_translation(EF)
    format_ef(EF)


Here are the resulting forces along the edges:

+--------+--------+--------+-----+-------+--------+-------+--------+-----+--------+-----+--------+--------+
| 0      | 1      | 2      | 3   | 4     | 5      | 6     | 7      | 8   | 9      | 10  | 11     | 12     |
+========+========+========+=====+=======+========+=======+========+=====+========+=====+========+========+
| 116.67 | 155.56 | 194.44 | 0.0 | 16.67 | 177.78 | 27.78 | 155.56 | 0.0 | 177.78 | 0.0 | 222.22 | 133.33 |
+--------+--------+--------+-----+-------+--------+-------+--------+-----+--------+-----+--------+--------+




<file_sep>/chcko/r/cv/en.rst
.. raw:: html

    %path = "maths/entropy"
    %kind = chindnum["texts"]
    %level = 12
    <!-- html -->

To exclusively select an element v (value, state, point) of a variable V
(cardinality `|V|=n`, n-set) we need `\log_bn` b-sets (normally `b=2`, bit).

.. math::

    I(V)=log\;n

`I(V)` is the code width of the variable, i.e. die information (in bits) needed
to select a value and it is the same for all values. `I` is a property of the variable.

.. admonition:: random variable, variate, variable

    A variate is a random variable.

    Often the distinction between random variable and variable is not
    necessary. Both mean a real quantity, whose values can occur repeatedly.

If we consider every occurrence `c \in C` of values of `V`,
then there is another way to refer to values of `V`.
We first choose an occurrence of any value with  `I(c)=\log |C|`
and subtract the information to select occurrences of `v\in V` (`I(c_v)=\log |C_v|`).
`\frac{|C|}{|C_v|}` is the number of `|C_v|` sized subsets of `C`.
So to select such a `v` occurrences subset we need

.. math::

    I(v)=\log\frac{|C|}{|C_v|}=-\log\;p(v)

This is different for all `v\in V` and represents the optimal code length for every value
(entropy code, Huffman code).

The average code width is

.. math::
    H(V)=-\sum_vp(v)\log\;p(v)

`H(V)` is the **entropy** of the variable `V` (note: not of a value of `V`).

The information in a variable depends on the probability distribution
of value occurrences (= random event).

<file_sep>/chcko/r/bq/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from chcko.chcko.hlp import Struct

import random
import sympy
from sympy.abc import x


def chiven():
    g = Struct()
    g.w = randrange(400, 500)
    g.h = randrange(150, 250)
    g.dw = randrange(30, 40)
    g.dh = randrange(40, 50)
    g.d = randrange(300, 500)
    return g


def chalc(g):
    w = g.w
    h = g.h
    dw = g.dw
    dh = g.dh
    d = g.d
    pi = x * (x - w)
    pimaxx = w / 2.0
    pimaxy = pi.subs(x, w / 2.0)
    pi = pi * h / abs(pimaxy)

    po = (x + dw) * (x - w - dw)
    pomaxx = w / 2.0
    pomaxy = po.subs(x, w / 2.0)
    po = po * (h + dh) / abs(pomaxy)

    ipo = sympy.integrate(-po, x)
    f1 = ipo.subs(x, 0) - ipo.subs(x, -dw)
    f2 = ipo.subs(x, w + dw) - ipo.subs(x, w)
    ipio = sympy.integrate(pi - po, x)
    f3 = ipio.subs(x, w) - ipio.subs(x, 0)
    f = f1 + f2 + f3
    v = f * d
    vm3 = v / 100.0 / 100.0 / 100.0

    return [vm3]
<file_sep>/chcko/r/h/__init__.py
# -*- coding: utf-8 -*-

import random
import numpy as np
from chcko.chcko.hlp import Struct, norm_frac as chorm


def chiven():
    k = np.array(random.sample(range(30, 60), 3))
    A = np.array([1, 0, 0] + random.sample(range(1, 19), 6))
    A.shape = (3, 3)
    Z = np.array(random.sample(range(1, 19), 3))
    m = np.array(random.sample(range(1, 19), 1))[0]
    g = Struct(k=k.tolist(), A=A.tolist(), Z=Z.tolist(), m=m)
    return g


def chalc(g):
    axy = np.dot(g.A, g.k)
    z = np.dot(g.Z, axy)
    K = g.m * z
    return [K]
<file_sep>/chcko/r/a2/__init__.py
from chcko.chcko.hlp import Struct
import random
from sympy import Integer
from itertools import product
from numpy import where
is_natural = lambda x: x.is_integer and x>=0
rch = random.choice
def chiven():
    g = Struct()
    random.seed()
    g.a = Integer(rch([-1,1]))
    op = '+-*/'
    opnd = product(op,['ab','ba'])
    ops = [o[0].join(o[1]) for o in opnd]
    random.shuffle(ops)
    takeop= lambda s: next(x for x in ops if s in x)
    g.ops = [takeop(s) for s in op]
    random.shuffle(g.ops)
    g.rep = ['b',f"{rch('+-')}{rch('23')}*a"]
    return g
def chalc(g):
    #g=chiven()
    res1 = [is_natural(eval(x.replace(*g.rep),{**g})) for x in g.ops]
    res = [''.join([chr(65+x) for x in where(res1)[0]])]
    return res
<file_sep>/chcko/r/bw/de.html
%path = "Mathe/Finanz/Zinsen/gemischt u. theoretisch"
%kind = chindnum["Übungen"]
%level = 11

Der Betrag von €{{chiven.K0}} wurde am {{chiven.d1.strftime('%d.%m.%Y')}}
auf die Bank gebracht und soll am {{chiven.d2.strftime('%d.%m.%Y')}}
mit Zinsen abgehoben werden. Die Bank rechnet volle Kalenderjahre (1.1. - 30.12, 12x30M, 360T)
mit Zinseszinsen und nicht volle Jahre linear (gemischte oder praktische Verzinsung).
Die Jahreszinsen der Bank sind {{chiven.i}}%.<br>
Berechne das Kapital zum Abhebezeitpunkt.
%chq(0)
<br>
Würde die Bank den ganzen Zeitraum mit Zinseszinsen rechnen,
wobei unvollständige Jahre als Brüche einfließten (theoretische Verzinsung),
um wieviel Euro unterschiede sich das Kapital zum Abhebezeitpunkt
bei dieser Berechnungsmethoden vom vorigen Ergebnis?
%chq(1)
<file_sep>/chcko/r/bo/__init__.py
# -*- coding: utf-8 -*-
from random import randrange, sample
from chcko.chcko.hlp import Struct
import numpy as np


def chiven():
    n = 5
    x = sorted(sample(range(20), n))
    p = randrange(3, 6)
    ymax = p * x[n - 1]
    kf = randrange(1, ymax // 3)
    yf = lambda v: int((1.0 * (ymax - kf) / x[n - 1] / x[n - 1]) * v * v + kf)
    y = [yf(ax) for ax in x]
    g = Struct(x=x, y=y, p=p)
    return g


def chalc(g):
    pf = np.polyfit(g.x, g.y, 2)
    pf = [-pf[0], g.p - pf[1], -pf[2]]
    xmax = np.roots(np.polyder(pf))
    ymax = np.polyval(pf, xmax)
    return [xmax[0], ymax[0]]
<file_sep>/chcko/r/cu/de.rst
.. raw:: html

    %path = "Mathe/Funktionen/Integral von 1÷z"
    %kind = chindnum["Texte"]
    %level = 12
    <!-- html -->

Aus der reellen Analysis wissen wir, dass
`\frac{dy}{dx}=\frac{d\,e^x}{dx}=e^x=y`, weswegen die Umkehrung
`\frac{dx}{dy}=\frac{d\,\ln y}{dy}=\frac{1}{y}` für `y>0`.  Für die
Stammfunktion von `\frac{1}{y}` kann man auch negative `y` mit einschließen,
wenn man den Betrag nimmt: `\int\frac{1}{y}dy=ln|y|+C`.  Das ergibt sich aus der
Symmetrie von `\frac{1}{y}`.  Bei 0 besteht eine Singularität, d.h. man kann dort nicht
darüber integrieren.

In `\mathbb{C}` ist `e^z=e^{x+iy}=e^xe^{iy}`,
d.h. der Realteil wird Betrag `e^x` und der Imaginärteil wird Argument des Wertes.
Daher kommt auch die Periode `2\pi i` entlang der imaginären Achse.
Die Stammfunktion von `\frac{1}{z}` ist die Umkehrfunktion von `e^z`,
d.h. der Betrag wird Realteil `ln|z|` und das Argument wird Imaginärteil:

`\int \frac{1}{z}dz=ln|z|+i\arg(z)+C`.

In `\mathbb{C}` kann man um die Singularität herum integrieren:

.. math::

    \oint_{|z|=1}\frac{1}{z}dz =
    (\ln|z| + i\arg z)\bigr|_{\arg z=0,\,|z|=1}^{\arg z=2\pi,\,|z|=1} = 2\pi i

Das ist ein Vorläufer des Residuensatzes.

<file_sep>/chcko/r/bf/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from chcko.chcko.hlp import Struct, listable


def chiven():
    g = Struct()
    g.a = randrange(20, 128)
    g.b = randrange(20, 128)
    return g


@listable
def chorm(a):
    return a.lstrip('0')


def chalc(g):
    return ['{0:b}'.format(g.a + g.b)]
<file_sep>/chcko/r/n/__init__.py
# -*- coding: utf-8 -*-

import random
import numpy as np
from chcko.chcko.hlp import Struct


def chiven():
    a = random.sample(range(30, 50), 1)[0] * 1000
    b = random.sample(range(50, 100), 1)[0] * 1000
    n = random.sample(range(3, 6), 1)[0]
    k = random.sample(range(6, 12), 1)[0]
    y = np.array(range(1, n + 1))
    T = np.sum((y * a + b) / (1 + 1.0 * k / 100) ** y)
    c = round(T, -3)
    dd = (T - c)
    d = dd * random.sample(range(-4, 5), 1)[0]
    c = round(T + d, -3)
    g = Struct(a=a, b=b, c=c, n=n, k=k)
    return g


def chalc(g):
    # g={'a':31000,'b':98000,'c':721000,'n':5,'k':9}
    y = np.array(range(1, g.n + 1))
    T = np.sum((y * g.a + g.b) / (1 + 1.0 * g.k / 100) ** y)
    dd = (T - g.c)
    return [T, 1 if dd > 0 else 2]
<file_sep>/README.rst
chko-r
======

`chko-r`_ is an example content package and test data for `chcko`_.
`chko-r`_ is a random mix of problems and texts.

A live version is available at:

    https://chcko.eu

This python package depends on the `chcko`_ python package,
which is not automatically installed,
because on gcloud `chcko`_ is *uploaded*, not installed.
Therefore locally install with::

    pip install --user chcko
    pip install --user chcko-r

There is no need to install,
if `chcko`_ is parallel to `chcko-r`_.

A content package can add additional dependencies.
This ``chcko-r`` depends on
`schemdraw <https://pypi.org/project/SchemDraw/>`__
`pint <https://pypi.org/project/Pint/>`__.
To install the dependencies without installing ``chcko-r``,
use ``pip install -r requirements.txt``.

Prepare content::

    make html

To run content locally with `chcko`_ installed::

    cd chcko-r
    runchcko

Install content::

    cd chcko-r
    pip install --user .

Image files are compiled to ``/chcko-r/chcko/_images``,
and copied to ``chcko/chcko/_images`` common to all `chcko`_ content when installing.
Image files need to have globally unique names across all ``chcko-<author_id>`` packages.
Use ``<author_id>_<problem_id>_xxx`` scheme,
e.g ``.. texfigure:: r_dg_c1.tex``.

Images can also be generated on the fly.
Examples:
`r.a3 <https://github.com/chcko/chcko-r/blob/master/chcko/r/a3/circuit.html>`__
`r.a4 <https://github.com/chcko/chcko-r/blob/master/chcko/r/a4/circuit.html>`__.

.. _`chcko`: https://github.com/chcko/chcko
.. _`chcko-r`: https://github.com/chcko/chcko-r


<file_sep>/chcko/conf.py

try:
    from chcko.chcko import conf
except ModuleNotFoundError:
    import sys
    import os.path as p
    chckoparallel = p.normpath(p.join(p.dirname(__file__),'..','..','chcko'))
    sys.path.insert(0,chckoparallel)
    from chcko.chcko import conf


globals().update({k:v for k,v in conf.__dict__.items() if not k.startswith('__')})

<file_sep>/chcko/r/dg/en.rst
.. raw:: html

    %path = "physics/circuits/thevenin"
    %kind = chindnum["examples"]
    %level = 13
    <!-- html -->

.. role:: asis(raw)
    :format: html latex


We will derive the gain of a band-stop filter using Thevenin's method.

Our starting circuit is the following from
`Op Amps for EveryOne (5-10) <http://www.ti.com/lit/an/slod006b/slod006b.pdf>`_.


.. texfigure:: r_dg_c1.tex
      :align: center

The input voltage is against the ground. We redraw the circuit to reflect this:

.. texfigure:: r_dg_c2.tex
      :align: center

We want to find `G=\frac{V_o}{V_i}`.
`V_o` is the voltage at the rightmost R. We will find the Thevenin equivalent there.


.. texfigure:: r_dg_c3.tex
      :align: center

Next we find the currents using Kirchhoff's current law (KCL) and voltage law (KVL).
There are two loops where current flows.
There is no current at the R at which we have made an open circuit

.. texfigure:: r_dg_c4.tex
      :align: center

The resulting equations are

.. math:: \begin{array}{l l l}
    V_i - I_2 R - \frac{I_2}{iwC} - I_1 R & = 0\\
    V_i - \frac{I_1 - I_2}{iwC} - I_1 R & = 0
    \end{array}

We solve for `I_1` and `I_2`:

.. math:: \begin{array}{l l}
    I_1 &= \frac{\omega C V_i (-2 i+C R \omega)}{-1-3 C R i \omega+C^2 R^2 \omega^2}\\
    I_2 &= -\frac{i \omega C V_i}{-1-3 C R i \omega+C^2 R^2 \omega^2}
    \end{array}

The small loop at `V_{th}` with the now known currents can be used to calculate

.. math:: V_{th}=\frac{I_2}{iwC} + I_1 R

Next we will need the Thevenin impedance equivalent. For this we remove the source `V_i`
and calculate the impedance as seen from `V_{th}`.

.. texfigure:: r_dg_c5.tex
      :align: center

We redraw to see a little better, what is parallel and what is serial

.. texfigure:: r_dg_c6.tex
      :align: center

With this we get

.. math:: Z_{th}=\left(\frac{1}{i \omega C}+\frac{R \frac{1}{i \omega C}}{R+\frac{1}{i \omega C}}\right) || R =
    \frac{R (1+2 i \omega C R)}{1+3 i \omega C R - C^2 R^2 \omega^2}

and

.. math:: V_o = \frac{R}{R + Z_{th}}

Then we finally have the **gain**:

.. math:: G = \frac{V_o}{V_i} = \frac{(-i+C R \omega)^2}{-2-5 i \omega C R+C^2 R^2 \omega^2}
    = \frac{(1+i \omega C R)^2}{2+5 i \omega C R-C^2 R^2 \omega^2}
    = \frac{(1+ s\tau)^2}{2+5 s\tau+(s\tau)^2}

We have replaced `\tau=R C` and `s=i \omega`, as is custom for filters.
The denominator can be solved for `s\tau` (-4.56,-0.44) and the product of the solutions is 2.
Therefore

.. math:: G = \frac{(1+ s\tau)^2}{2(1+\frac{s\tau}{0.44})(1+\frac{s\tau}{4.56})}

<file_sep>/chcko/r/cv/de.rst
.. raw:: html

    %path = "Mathe/Entropie"
    %kind = chindnum["Texte"]
    %level = 12
    <!-- html -->

Um exklusiv ein Element v (Wert, Zustand, Punkt) von einer Variablen V
(Kardinalität `|V|=n`, n-Menge) auszuwählen, braucht es `\log_bn` b-Mengen
(normalerweise `b=2`, bit).

.. math::

    I(V)=log\;n

`I(V)` ist die Breite der Variable, d.h. die Informationsmenge (Anzahl von bits),
die es braucht, um Werte von V auszuwählen. `I` ist gleich für alle Werte von V.
`I` bezieht sich auf die Variable.

.. admonition:: Zufallsvariable, Variate, Variable

    Im Englischen gibt es Variate für Zufallsvariable (random variable).

    Oft ist diese Unterscheidung zwischen Zufallsvariable und Variable nicht
    notwendig. Beides meinen hier die reale Größe mit Werten, die wiederholt
    auftreten können.

Wenn man jeden bekannten Auftritt (Verweis, Ereignis) `c \in C` der
Werte von `V` betrachtet, dann ist das ein zusätzlicher Weg, um auf die
Werte von `V` zu verweisen.  Man wählt zuerst einen beliebigen Auftritt aus
mit `I(c)=\log |C|` und subtrahiert davon die Auswahl eines Auftritts eines
bestimmten Wertes `v` (`I(c_v)=\log |C_v|`).  `\frac{|C|}{|C_v|}` ist die
Anzahl von `|C_v|` großen Untermengen von `C`.  Um einen solchen Untermenge einmal
auszuwählen braucht es

.. math::

    I(v)=\log\frac{|C|}{|C_v|}=-\log\;p(v)

`I(v)` ist für jedes `v\in V` anders und stellt den optimalen Code dar
(Entropie Code, Huffman code).

Die durchschnittliche Codebreite ist

.. math::
    I(V)=-\sum_vp(v)\log\;p(v)

`I(V)` ist die **Entropie** der Variablen `V` (und nicht eines Wertes von `V`).

Wenn für alle `v` `p=\frac{1}{n}` ist, dann sind erhält man wieder `I(V)=log\;n`.

Die Information in einer Variablen hängt von der Wahrscheinlichkeitsverteilung
der Wertauftritte (= Wahrscheinlichkeitsereignis) ab.



<file_sep>/chcko/r/by/__init__.py
# -*- coding: utf-8 -*-
from random import randrange, sample
from math import pi, sin
from chcko.chcko.hlp import Struct


def chiven():
    al, be = sample(range(10, 85), 2)
    c = randrange(2, 20)
    g = Struct(al=al, be=be, c=c)
    return g

##g = Struct(al=39,be=69,c=13)
#g = chiven()
# chalc(g)


def chalc(g):
    ga = 180 - g.be - g.al
    csga = g.c / sin(pi * ga / 180)
    a = sin(pi * g.al / 180) * csga
    b = sin(pi * g.be / 180) * csga
    return [a, b]

chames=[r'\(a=\)',r'\(b=\)']
<file_sep>/chcko/r/bt/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from chcko.chcko.hlp import Struct

import sympy
from sympy import S, Rational as R
from sympy.abc import x


def chiven():
    a = 1
    b = R(randrange(3, 6))
    c = R('0.6') + randrange(5) * R(1, 10)
    e = c + randrange(4) * R(1, 10)
    d = a + randrange(5, 9)
    f = e + randrange(4, 7)
    j = f - R(1, 2)
    g = d + R(1, 2)
    h = d + randrange(4, 9)
    k = R(b - c, a * a)
    u = -k * x ** 2 + b
    v = (e - c) / (d - a) * (x - a) + c
    l = (f - e) / (h - d) ** R(1, 2)
    w = l * (x - d) ** R(1, 2) + e
    z = l * (x - d) ** R(1, 2)
    dc = Struct(
        u=sympy.sstr(u),
        v=sympy.sstr(v),
        w=sympy.sstr(w),
        z=sympy.sstr(z),
        d=d,
        g=g,
        h=h)
    return dc


def chalc(dc):
    p1 = sympy.integrate(sympy.pi * S(dc.u) ** 2, (x, 0, 1))
    p2 = sympy.integrate(sympy.pi * S(dc.v) ** 2, (x, 1, S(dc.d)))
    p3 = sympy.integrate(sympy.pi * S(dc.w) ** 2, (x, S(dc.d), S(dc.h)))
    m4 = sympy.integrate(sympy.pi * S(dc.z) ** 2, (x, S(dc.g), S(dc.h)))
    res = S(p1 + p2 + p3 - m4).n()
    return [res]
<file_sep>/chcko/r/g/__init__.py
# -*- coding: utf-8 -*-
import random
from sympy.abc import x
from sympy.solvers import solve
from sympy import sstr, apart, S
from chcko.chcko.hlp import Struct, norm_frac as chorm


def chiven():
    a, b, c, d, e, f = random.sample(list(range(-9, -1)) + list(range(1, 9)), 6)
    #x = a/b
    rs = a - c
    ls = b * x - c
    rs = d * rs / ls
    ls = 1 - e * x / (d + e * x)
    rs = rs / (d + e * x)
    rs = apart(rs)
    ls = ls / f
    rs = rs / f
    ls1, ls2 = ls.as_two_terms()
    rs1, rs2 = rs.as_two_terms()
    g = Struct()
    g.sls = sstr(S(ls1) + S(ls2))
    g.srs = sstr(S(rs1) + S(rs2))
    return g


def chalc(g):
    try:
        sol = solve(S(g.sls) - S(g.srs), x)[0]
        return [sol]
    except:
        return ['-']
<file_sep>/chcko/r/di/de.rst
.. raw:: html

    %path = "Mathe/Zahlen/C"
    %kind = chindnum["Texte"]
    %level = 9
    <!-- html -->

.. contents::

Die komplexen Zahlen `\mathbb{C}`
---------------------------------

Bei den reellen Zahlen (:lnk:`r.ci`) haben wir immer wieder neue Mengen zu den
"Zahlen" hinzu genommen.

Das machen wir bei folgendem Problem auch.

`x^2` nimmt nur positive Werte an.

- Es geht Information verloren (die Wertemenge ist kleiner) und
- Gleichungen wie `x^2+1=0` können nicht gelöst werden

Wenn wir ein "Zahl" `i` erfinden die `i^2=-1` ergibt, dann deckt `x^2` mit den Vielfachen
von `i` die ganzen negativen Zahlen ab. `i` nennen man **imaginäre Einheit**.

`i` und deren Vielfache haben mit den reellen Zahlen vorerst nichts zu tun.
Sie sind orthogonal zu `\mathbb{R}`. Orthogonal bedeutet, dass alle Kombinationen
zulässig sind und das entspricht einer Ebene, der **komplexen Zahlenebene** oder
**Gaussschen Zahlenebene**.

    `z = a + ib \in \mathbb{C}`

Das ist wie ein zweidimensionaler Vektor: 2 orthogonale Richtungen unabhängig addiert.

Es gibt drei Darstellungen

- `z = a+ib`, also über Komponenten oder
- `z = r(cos\varphi + i sin\varphi)` über Länge `r` und Richtung `\varphi` (Argument, Phase) in Bogenmaß.

Aber nun folgendes:

- `i\cdot 1 = i`, also Multiplikation mit `i` macht aus 1 ein `i` das orthogonal zu
  1, der **reellen Einheit**, ist. Das ist eine Drehung um den rechten Winkel nach links.
- `i\cdot i = -1`. Wieder eine Drehung um den rechten Winkel.

Allgemein: Multiplikation mit `i` macht eine Drehung um den rechten Winkel, per Konvention nach links.

Weiters: Multiplikation addiert den Winkel dazu, d.h. Multiplikation führt zur
Addition des Winkels.  Das lässt einen vermuten, dass es eine Darstellung geben
könnte, die den Winkel im Exponenten hat.  Reihenentwicklung von `\sin` und `\cos`
und `e^x` in der Analysis und Vergleich ergibt die **Eulersche Formel**:

- :inl:`r.cy`

`z=re^{i\varphi}` ist die **Normaldarstellung** komplexer Zahlen.

Von `\sin` und `\cos` weiß man, dass sie die Periode `2\pi` haben, so auch `e^{i\varphi}`.
Die n-te Wurzel teilt alle Perioden bis `2n\pi` auf unter `2\pi` und somit zu n
unterschiedlichen Werten:

.. math::

    z^{1/n}=r^{1/n}e^{i(\varphi/n+2k\pi/n)}

Allgemeiner:

   In `\mathbb{C}` hat jedes Polynom n-ten Grades genau n Nullstellen
   (**Hauptsatz der Algebra**). Davon können manche aber zusammenfallen.
   `\mathbb{C}` heißt deshalb **algebraisch abgeschlossen**.

Das heißt, dass nicht nur `x^2`, sondern alle Polynome ganz `\mathbb{C}` auf ganz `\mathbb{C}` abbilden.
Es geht keine Information verloren.

.. admonition:: Hinweis

    In der Funktionentheorie erfährt man, das sich das auf alle Funktionen
    ausdehnen lässt, die in ganz `\mathbb{C}` unendlich oft differenzierbar
    (analytisch, holomorph) sind (ganze Funktionen), da sie sich in
    Taylorreihen entwickeln lassen.

Weiteres:

- a = Re(z) ist der Realteil

- b = Im(z) ist der Imaginärteil

- `\bar{z}=re^{-i\varphi}=a-ib` heißt (komplex) Konjugierte zu z. `\bar{z^n}=\bar{z}^n`.

  `z_1\bar{z_2}` vereint in sich Skalarprodukt (`Re(z_1\bar{z_2})=r_1r_2\cos\Delta\varphi`) und Vektorprodukt
  (`Im(z_1\bar{z_2})=r_1r_2\sin\Delta\varphi`).

- `|z| = \sqrt{z\bar{z}} = \sqrt{a^2+b^2} = r` ist der Betrag (oder Modul) von z.

  Das Quadrat über die Länge einer komplexen Zahl unabhängig von ihrer Richtung
  ergibt sich durch `z\bar{z}` und nicht durch `z^2`.

- `φ = arg(z)` ist Argument (oder Phase) von z.

  - `arg(z_1z_2)=arg(z_1)+arg(z_2)`

  - `arg(\frac{z_1}{z_2})=arg(z_1)-arg(z_2)`


Anwendung von `\mathbb{C}`
--------------------------

Da `\mathbb{C}` eine Erweiterung von `\mathbb{R}` darstellt,
kann man alles mit `\mathbb{C}` machen, was man mit `\mathbb{R}` macht.
Das essentiell Neue an `\mathbb{C}` sind aber alle Richtungen, statt nur `+` und `-`.

Was heißt Richtung?

:inline:`r.ct`

Die komplexen Zahlen werden in der Physik und Technik im Umfeld von Schwingungen und Wellen
verwendet, und davon gibt es viele:

- Mechanik/Festkörper: Wasserwellen, Schallwellen, elastische Wellen,...

- Elektrotechnik: Wechselstrom, Wechselstromkeis (Widerstand, Kapazität und Induktivität),...

- Elektrodynamik: Elektromagnetische Wellen (Lichtwellen, Radiowellen), ...

- Optik: Lichtwelle, ...

- Quantenmechanik: Teilchenwellen, ....

Letztendlich basieren diese Anwendungen auf dem uneingeschränkteren Rechnen in `\mathbb{C}`
und auf den mathematisch auf `\mathbb{C}` aufbauenden Ergebnissen etwa der Funktionentheorie.

Viele physikalische Systeme werden mit Differentialgleichungen beschrieben.
Diese reduzieren sich auf Polynome mit komplexen Lösungen (Fundamentalsatz der Algebra)
und führen zu komplexen Funktionen.


<file_sep>/chcko/r/cj/de.rst
.. raw:: html

    %path = "Mathe/Zahlen/Kombination mit Operationen"
    %kind = chindnum["Texte"]
    %level = 9
    <!-- html -->

Kombiniert man mit der Anzahl, also der natürlichen Zahl,
den Vorgang (Operation) des Hinzufügens und dessen Umkehrung,
dann kommt man zu den **ganzen Zahlen**.

.. math::

    \mathbb{Z} = \mathbb{N}\times\{+,-\}

Wiederholung des Hinzufügen ist Vervielfachung.

Kombiniert man mit der ganzen Zahl
den Vorgang (Operation) des Vervielfachens und dessen Umkehrung,
dann kommt man zu den **rationalen Zahlen**.

.. math::

    \mathbb{Q} = \mathbb{Z}\times\{+,-\}\\
    \mathbb{Q} = \mathbb{N}\times\{+,-\}\times\{\cdot,\div\}


Wiederholen des Vervielfachens ist Potenzieren.

Nicht mehr so analog, aber prinzipiell erhält man
durch Kombination der rationalen Zahlen mit dem Potenzieren eine
Erweiterung, die **algebraischen Zahlen**.

Bis jetzt wurden Zahlen mit Vorgängen/Operation kombiniert.  Das ist ein
Algorithmus. Erlaubt man auch nicht endende Algorithmen, dann schließt man die
**irrationalen Zahlen** (algebraische und transzendente Zahlen) mit ein und
erweitert zu den **reellen Zahlen** \mathbb{R}.

.. admonition:: Hinweis

    Endlicher oder unendlicher Algorithmus: `\sqrt{2}` ist mit den
    Grundrechnungsarten ausgedrückt ein unendlicher Algorithmus. Wertet man
    `\sqrt{2}` nicht aus, sondern hantiert symbolisch mit ihm, dann ist das
    wieder ein endlicher Algorithmus.
<file_sep>/chcko/r/ck/__init__.py
# -*- coding: utf-8 -*-
from __future__ import division
from random import randrange
from chcko.chcko.hlp import Struct, norm_int as chorm


def chiven():
    return Struct(
        A=randrange(150, 200), B=randrange(100, 150), C=randrange(50, 100)
    )


def chalc(g):
    # g=chiven()
    # g=Struct(A=200,B=150,C=100)
    # total unknown but assumed known
    # p1=g.A/total
    # p2=g.B/total
    # p = p1*p2 #p1 and p2 independent
    # total*p = g.A*g.B/total = g.C
    total = g.A * g.B // g.C  # converts to int
    detected = g.A + g.B - g.C
    undetected = total - detected
    return [undetected]
<file_sep>/chcko/r/b/de.rst
.. raw:: html

    %path = "Mathe/Vektoren"
    %kind = chindnum["Texte"]
    %level = 11
    <!-- html -->

Vektoren
--------

Was ist ein Vektor?
...................

    Einen **mehrdimensionalen Vektor** kann man als unabhängige Auswahl (Wert) von
    mehreren Variablen verstehen.

    Die Werte (Zahl+Einheit) müssen unabhängig **addierbar** sein.

    Die jeweiligen Einheiten sind die **Einheitsvektoren**.  Sie bilden
    zusammen die **Basis** und werden deshalb auch **Basisvektoren** genannt.

    Auch eine Auswahl aus einer Variable ist ein Vektor, ein **eindimensionaler** Vektor.

    Der gesamte Vektor kann mit einer Zahl, dem **Skalar**, multipliziert
    werden und ergibt wieder ein Vektor.

Beispiel

    - Wenn ich in einen Laden gehe, dann sind die Produkte darin mein
      Vektorraum (Koordinatensystem, KS) und mein Einkaufskorb ist ein Vektor,
      d.h. eine Fixierung der Werte (wieviel?) von jeder Variable (hier Produkt).
    - Wenn meine Frau auch einkaufen gegangen ist, addieren sich unsere Einkäufe zu hause unabhängig,
      d.h. Milch + Milch, Butter + Butter, ...

Koordinatentransformation
.........................

Eine Matrix transformiert eine Vektor in einem Vektorraum zu einem Vektor in einem anderen Vektorraum.
Deshalb lernen wir zuerst den Vektor kennen. Eine Matrix ergibt sich, wenn wir
von einem KS zu einem anderen wechseln wollen.

Beispiel :inline:`r.a0`


Wie schreibt man Vektoren?
..........................

- Als Spalte von Zahlen `\vec{x}=\begin{pmatrix}x_1\\x_2\end{pmatrix}`
  Die Einheitsvektoren, d.h. was die Zeilen bedeuten, gibt man separat an.
- Explizit mit Einheiten ausgeschrieben. `\vec{x}=x_1\vec{e_1}+x_2\vec{e_2}` (3
  Milchpackungen + 5 Butter) Wenn ohne Pfeil ist mit Index oben die Zahl
  gemeint und mit Index unten die Einheit (Dimension,Richtung):
  `x=x^1e_1+x^2e_2`.

Notation is nicht der Vektor selbst.

Vektorverknüpfungen
-------------------

.. .. texfigure:: vector_dot_cross.tex
..       :align: center

.. tikz:: \coordinate (0) at (0,0);
    \coordinate (A) at (1,3);
    \coordinate (B) at (4,2);
    \coordinate (C) at (2,1);
    \tikzset{->}
    \draw[black,very thick] (0) -- (A) node [midway,left]{$\vec{x}$};
    \draw[black,very thick] (0) -- (B) node [near end,right,below]{$\vec{y}$};
    \draw[black,very thin]  (0) -- (C) node [midway,right,below]{$x_y$};
    \draw[-,thin] (A) -- (C) node [midway,right]{$x_{\perp y}$};


Es gibt neben der Addition zwei weitere wichtige Vektorverknüpfungen.

- **Skalarprodukt (dot-product)**. Es ergibt eine Zahl (Skalar), welche die
  Abhängigkeit darstellt oder inwiewenig man unabhängig Werte auswählen kann.

  .. math:: \vec{x}\vec{y}=x_yy=y_xx=x_1y_1+x_2y_2

  - Orthogonale Vektoren ergeben 0 (keine Abhängigkeit).

  - Bei parallelen Vektoren ist es das Produkt der Längen.
    Die Länge eines Vektors `\vec{x}` ist damit `\sqrt{\vec{x}\vec{x}}`.
    Länge wird als `|\vec{x}|` oder einfach nur `x` notiert.

  - `\vec{x_o}=\frac{\vec{x}}{x}` ist der Einheitsvektor (Länge 1, Richtung von `\vec{x}`)

  - Das skalare Produkt definiert den Winkel zwischen 2 Vektoren: `\cos\alpha = \frac{\vec{x}\vec{y}}{xy}`


- **Vektorprodukt oder Kreuzprodukt (cross-product)**. Für Dimension `= 3`.
  Es ergibt einen Vektor der orthogonal zu `\vec{x}` und `\vec{y}` ist
  und die Länge ist die Fläche des von `\vec{x}` und `\vec{y}` aufgespannten Parallelogramms.

  .. math::
        \vec{x}\times\vec{y}=x_{\perp y}y=y_{\perp x}x=
        \begin{vmatrix}
        \vec{e_1} & \vec{e_2} & \vec{e_3} \\
        x_1 & x_2 & x_3 \\
        y_1 & y_2 & y_3
        \end{vmatrix}

  Wenn `\vec{x}` und `\vec{y}` zweidimensional sind, ist nur die `\vec{e_3}` Komponente von
  `\vec{x}\times\vec{y}` ungleich 0, die dann gleich
  `\begin{vmatrix}
  x_1 & x_2 \\
  y_1 & y_2
  \end{vmatrix}=
  \begin{vmatrix}
  x_1 & y_1 \\
  x_2 & y_2
  \end{vmatrix}`
  ist. Zum Vergleich: Die Determinante von 3 Vektoren im 3D Raum ist das
  Volumen des aufgespannten Parallelepipeds.


<file_sep>/chcko/r/bl/de.html
%path = "Mathe/Finanz/Zinsen/Vergleich Zinssatz"
%kind = chindnum["Übungen"]
%level = 11

Welcher Zinsatz ist nach konformer (äquivalenter) Berechnung besser? <br>
%include('r/bl/x_')

<file_sep>/chcko/r/cn/en.rst
.. raw:: html

    %path = "maths/numbers/representation"
    %kind = chindnum["texts"]
    %level = 9
    <!-- html -->

The numbers are their own concepts independent from their representations.

The `wikipedia article <http://en.wikipedia.org/wiki/Numeral_system>`_
gives a great overview beyond the
`positional system <http://en.wikipedia.org/wiki/Positional_notation>`_
described here.

Positional System
=================

It is not possible to give every number its own sign.  Instead we use signs
up to a certain count and then one makes heaps (groups) of that count and
starts counting these heaps.

.. admonition:: Note

    One can compare the numeral system with letters or phonetic systems.
    In a language one combines phonemes to produce a multitude, i.e. the words.
    These are associated/mapped to concepts.
    With Numbers digit signs are combined and then mapped to a count and beyond.

The Decimal System
------------------

- For a count below ten there are signs: 1, 2, 3, 4, 5, 6, 7, 8, 9.
- For "none" there is **0**. Together these are 10 signs.
- For a count ten and above one makes heaps of ten and counts these separately.

Position coding:

    Instead of writing 3 tens and 4 ones we write 3 at a position for the tens
    and 4 for the position for the ones: 34.
    This can be called position coding: Via the position we identify what we mean.

    302 means 3 heaps of tens of tens (hundred), 0 (no) tens and 2 ones.

Position value:
    The value of the position increases from right to left

    ...  10³=1000 10²=100 10¹=10 10⁰=1

    These are powers of 10.
    10 is the **base** of the decimal system.

    Fractions:

    As heaps of 10 get a position also fractions in 10th get a position to the right
    of the dot (.)

    ,1/10¹=1/10  1/10²=1/100  1/10³=1/1000 ...

The Binary System
-----------------

In the dual system two things make their own heap.

Together with the 0 the binary system has 2 signs, which mean: **there or not there**

The position values of the positions are these

    ...  2⁴=16 2³=8 2²=4 2¹=2 2⁰=1 . `2^{-1}` `2^{-2}` ...

Example

    1011₂ = 11₁₀

The binary system is important, because computers use it and because 2 is the
smallest quantity one can still choose from.

The Hexadecimal System
----------------------

Here we make heaps of 16.

Together with the 0 we have 16 signs:

    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

The new ones are A=10, B=11, C=12, D=13, E=14, F=15.

The position values are:

    ... 16⁴=65536 16³=4096 16²=256 16¹=16 16⁰=1 .  `16^{-1}` `16^{-2}` ...

Because of 2⁴=16, one needs 4 binary digits for one hexadecimal digit.
Since the binary system is important, the hexadecimal is important, too,
and so are other systems with base power of 2,
like. Base 8 (octal), 64 (base64), 128(ASCII) and 256 (ANSI).

Duodecimal System
-----------------

Twelve has many divisors: 2, 3, 4, 6
This allows an easy representation of fractions with these denominators.

But as with the decimal system (1/3 = 0.333...)
the duodecimal system has easy fractions that are periodic (1/5 = 0.2497 2497...).



<file_sep>/chcko/r/bp/de.html
%path = "Mathe/Integral/bestimmtes/Volumen/Zylinder oder Rotation"
%kind = chindnum["Übungen"]
%level = 12

Es soll ein Bonbon in Fischform erzeugt werden.
Das Fischprofil wird nach oben durch folgende Funktionen begrenzt.<br>
\(y={{ chutil.TX(chiven.f) }}\), 0<=x<{{ chiven.b }}<br>
\(y={{ chutil.TX(chiven.g) }}\), {{ chiven.b }}<=x<{{ chiven.c }}<br>
\(y={{ chutil.TX(chiven.h) }}\), {{ chiven.c }}<=x<{{ chiven.d }}<br>
Nach unten entsteht die Begrenzung durch Spiegeln an der x-Achse.
<ol>
    <li>Skizziere dieses Profil.</li>
    <li>Berechne das Volumen einer Zylindervariante mit Höhe {{chiven.t}}.
    <br>\(V_p=\)
    %chq(0)
    </li>
    <li>Berechne das Volumen einer Rotationsvariante (um die x-Achse).
    <br>\(V_r=\)
    %chq(1)
    </li>
</ol>
<file_sep>/chcko/r/cd/en.rst
.. raw:: html

    %path = "maths/finance/interest"
    %kind = chindnum["texts"]
    %level = 10
    <!-- html -->


`K` Capital

    An amount of money.

`i` Interest rate

    The increase or decrease of capital `K` is notated in percent %=1/100.

    - interest value: `3\% K = 0.03 K`.
    - increase : `K + 3\% K = (1+3\%) K = 1.03 K`.
    - decrease : `K - 3\% K = (1-3\%) K = 0.97 K`.

`n` Period (Year/Quarter/Month/Day)

    The interest rate `i` always refers to a time period, in which the increase or decrease
    takes place (is compounded)

    - `i` normally refers to a full year (annual interest rate, effective annual interest rate)
    - `i_{12}` is a monthly interest rate
    - `i_4` is a quarterly interest rate

    After this time period `K` has grown by `iK`, i.e. `K_{n=1} = K_0 (1+i) = K_0 q` (q = 1+i).

Compound interest

    After one period the capital becomes `K_{n=1} = K_0 (1+i) = K_0 q`,
    after n=2 periods `K_0 q^2`, after n=3 periods `K_0 q^3`...

    After n periods:

    - `K_n = K_0 q^n`

    - compound interests: multiply the starting capital (principal) with `q^n`
      to get the value `n` periods later.
    - discount interests: multiply the capital with `q^{-n}` to get the value `n` periods earlier.

.. http://en.wikipedia.org/wiki/Time_value_of_money

Annuity

    An annuity is a payment `r` in regular time periods.
    The number of periods for the annuity depends on the payment.
    The accrued payments make up the lump-sum. This is the pension or **annuity formula**:

    `R_n = \sum_{m=0}^{n-1} r_m = \sum_{m=0}^{n-1} r q^m = r \frac{q^n - 1}{q-1}`

    The formula can be used to calculate the **future value** (FV)`R_n`
    when the interests are compounded at the end of the periods.

    Annuity due is when compounded at the beginning: `R_n^v = q R_n`

    The **present value** (PV) of an annuity is obtained by discounting from the FV:
    `B_n = R_n q^{-n}`.

Compounding periods smaller than a year

    To compare the effective annual rate of interest with the rate for the period one converts the rates.

    In a linear conversion we use when there is no compounding taking place

    - `i_{12} = i/12`
    - `i_4 = i/4`

    With compounding the effective annual interest rate is calculated with the **conformal** conversion:
    Effective `i_{eff}` distinguishes from nominal interest rate `i`.

    - `i_{eff} = (i_{12} + 1)^{12} - 1`
    - `i_{eff} = (i_4 + 1)^4 - 1`

    Normally the annual interest rate is given.
    For a monthly or quarterly compounding this first needs to be converted.

Annuity rest

    To calculate the remaining value of the annuity at a certain time
    one subtracts the future value of the annuity for that time from
    the capital value for that time.

Convert one annuity to another

    - First one finds the future value `R_n`.
    - This `R_n` needs to be compounded to the end of the other annuity.
    - Using the annuity formula one can calculate the requested quantity (`n`, `q`, `r`)
      of the new annuity.

Comparison of capitals or offers

    To compare values one must first compound their values to the same time
    (time-value, e.g. present value) using the compounding or annuity formulas.


<file_sep>/chcko/r/cb/__init__.py
# -*- coding: utf-8 -*-

from chcko.chcko.hlp import Struct, norm_frac as chorm
import random
from sympy import Rational as R

__all__ = ['chiven', 'chalc']


def chiven():
    g = Struct()
    g.x = random.sample(list(range(-9, -1)) + list(range(1, 9)), 2)
    g.b = random.sample(list(range(-9, -1)) + list(range(1, 9)), 1)[0]
    return g


def chalc(g):
    res = [R(g.b, g.x[1])]
    return res
<file_sep>/chcko/r/p/__init__.py
# -*- coding: utf-8 -*-

import random
from math import log

from chcko.chcko.hlp import Struct, norm_frac as chorm

be = []
for i in range(2, 5):
    for j in range(-4, 5):
        be.append((i, j))
for i in range(2, 5):
    for j in range(-4, 5):
        be.append((1.0 / i, j))
random.shuffle(be)


def chiven():
    b, e = random.sample(be, 1)[0]
    n = 1.0 * b ** (1.0 * e)
    g = Struct(b=b, n=n)
    return g


def chalc(g):
    res = 1.0 * log(g.n) / log(g.b)
    return [res]
<file_sep>/chcko/r/o/__init__.py
# -*- coding: utf-8 -*-

import random
from sympy import latex, Poly, Rational
from sympy.abc import x

from chcko.chcko.hlp import Struct, norm_frac as chorm

__all__ = ['chiven', 'chalc', 'chorm', 'tex_lin']


def tex_lin(a, b):
    p = Poly([a, b], x, domain='QQ')
    return latex(p.as_expr())


def chiven():
    # ax+b=cx
    a, c = random.sample(list(range(2, 10)) + list(range(-9, -2)), 2)
    da, dc = random.sample(list(range(2, 4)) + list(range(-3, -1)), 2)
    xx = random.sample(list(range(1, 6)) + list(range(-5, 0)), 1)[0]
    b = (Rational(c, dc) - Rational(a, da)) * xx
    g = Struct(a=Rational(a, da), b=b, c=Rational(c, dc))
    return g


def chalc(g):
    return [1.0 * g.b / (g.c - g.a)]
<file_sep>/chcko/r/bz/en.html
%path = "maths/trigonometry/slope"
%kind = chindnum["problems"]
%level = 11

A piece of road covers a height difference of {{ chiven.h }}m
in a slope length of {{ chiven.l }}m.<br>
What is the slope in percent?
%chq(0)
<br>
What ist the ascent angle in degrees?
%chq(1)
<file_sep>/chcko/r/w/__init__.py
# -*- coding: utf-8 -*-

import random

from chcko.chcko.hlp import Struct, norm_frac as chorm

be = []
for i in range(2, 5):
    for j in range(-4, 5):
        be.append((i, j))
for i in range(2, 5):
    for j in range(-4, 5):
        be.append((1.0 / i, j))
random.shuffle(be)


def chiven():
    b, e = random.sample(be, 1)[0]
    g = Struct(b=b, e=e)
    return g


def chalc(g):
    x = 1.0 * g.b ** (1.0 * g.e)
    return [x]
<file_sep>/chcko/r/cw/de.rst
.. raw:: html

    %path = "Mathe/Informatik/Komplexität"
    %kind = chindnum["Texte"]
    %level = 9
    <!-- html -->

Komplexität

    Um auf einen Wert einer Variable zu verweisen, braucht es Speicher.
    Ergibt sich der Wert jedoch aus Werten anderer Variablen,
    erpart man sich diesen Speicher. Das ist ein Grund,
    warum Funktionen wichtig sind.

    Andererseits muss man dann Berechnungen machen, um vom Wert einer
    Variable auf den Wert der anderen Variable zu schließen. Das braucht
    Zeit.

    **Komplexität** gibt das Ausmaß der benötigten Resourcen wieder. Wenn
    viel Zeit gebraucht wird, dann ist die Zeitkomplexität hoch.
    Wenn viel Speicher bebraucht wird, dann ist die Speicherkomplexität
    oder Raumkomplexität hoch.

    Da Computer unterschiedlich schnell sind, gibt man nur die Größenordnung
    in Abhängigkeit von der Kardinalität `n` der Eingabemenge in der O-Notation an,
    etwa `O(n^2)`.

<file_sep>/chcko/r/initdb.py
# -*- coding: utf-8 -*-
# generate via ``doit -kd. initdb``
def populate_index(index_add):
    index_add("r.a", "de", "0", "11",
        "Mathe/Trigonometrie/SSS")
    index_add("r.a", "en", "0", "11",
        "maths/trigonometry/sss")
    index_add("r.a0", "de", "1", "11",
        "Mathe/Vektoren")
    index_add("r.a0", "en", "1", "11",
        "maths/vectors")
    index_add("r.a1", "de", "1", "12",
        "Physik/S=E*t")
    index_add("r.a1", "en", "1", "12",
        "physics/S=E*t")
    index_add("r.a2", "de", "0", "9",
        "Mathe/Zahlen/NZQR")
    index_add("r.a2", "en", "0", "9",
        "maths/numbers/NZQR")
    index_add("r.a3", "de", "0", "10",
        "Elektronik/Transistor/BJT/R")
    index_add("r.a3", "en", "0", "10",
        "electronics/transistor/BJT/R")
    index_add("r.a4", "de", "0", "10",
        "Elektronik/Transistor/BJT/V")
    index_add("r.a4", "en", "0", "10",
        "electronics/transistor/BJT/V")
    index_add("r.a5", "en", "1", "12",
        "maths/differential/introduction")
    index_add("r.b", "de", "1", "11",
        "Mathe/Vektoren")
    index_add("r.b", "en", "1", "11",
        "maths/vectors")
    index_add("r.ba", "de", "0", "10",
        "Mathe/Folgen und Reihen/arithmetische u. geometrische")
    index_add("r.ba", "en", "0", "10",
        "maths/sequences and series/arithmetic and geometric")
    index_add("r.bb", "de", "0", "10",
        "Mathe/Dreieck/rechtwinkliges")
    index_add("r.bb", "en", "0", "10",
        "maths/triangle/rectangular")
    index_add("r.bc", "de", "0", "11",
        "Mathe/Finanz/Rentenrechnung/ganzjährig->unterjährig")
    index_add("r.bc", "en", "0", "11",
        "maths/finance/annuity/annual->monthly")
    index_add("r.bd", "de", "0", "11",
        "Mathe/Log/Rentenlaufzeit")
    index_add("r.bd", "en", "0", "11",
        "maths/log/annuity runtime")
    index_add("r.be", "de", "0", "9",
        "Mathe/Zahlensysteme/Binärsystem/Umwandeln")
    index_add("r.be", "en", "0", "9",
        "maths/number system/binary/convert")
    index_add("r.bf", "de", "0", "9",
        "Mathe/Zahlensysteme/Binärsystem/Addieren")
    index_add("r.bf", "en", "0", "9",
        "maths/number system/binary/add")
    index_add("r.bg", "de", "0", "9",
        "Mathe/Zahlensysteme/Binärsystem/Dividieren")
    index_add("r.bg", "en", "0", "9",
        "maths/number system/binary/divide")
    index_add("r.bh", "de", "0", "9",
        "Mathe/Zahlensysteme/Binärsystem/Multiplizieren")
    index_add("r.bh", "en", "0", "9",
        "maths/number system/binary/multiply")
    index_add("r.bi", "de", "0", "9",
        "Mathe/Zahlensysteme/Binärsystem/Subtrahieren")
    index_add("r.bi", "en", "0", "9",
        "maths/number system/binary/subtract")
    index_add("r.bj", "de", "0", "11",
        "Mathe/Funktionen/exponentiell")
    index_add("r.bj", "en", "0", "10",
        "maths/functions/exponential")
    index_add("r.bk", "de", "0", "11",
        "Mathe/Vektoren/Matrix/Torten")
    index_add("r.bk", "en", "0", "11",
        "maths/vectors/matrix/cakes")
    index_add("r.bl", "de", "0", "11",
        "Mathe/Finanz/Zinsen/Vergleich Zinssatz")
    index_add("r.bl", "en", "0", "11",
        "maths/finance/interest/comparison")
    index_add("r.bm", "de", "0", "12",
        "Mathe/Finanz/Kosten- u. Preistheorie/Cournot")
    index_add("r.bm", "en", "0", "12",
        "maths/finance/cost and price theory/cournot")
    index_add("r.bn", "de", "0", "10",
        "Mathe/Log/Verzinsungszeit")
    index_add("r.bn", "en", "0", "10",
        "maths/log/interest time")
    index_add("r.bo", "de", "0", "12",
        "Mathe/Finanz/Kosten- u. Preistheorie/Gewinnmodell")
    index_add("r.bo", "en", "0", "12",
        "maths/finance/cost and price theory/profit model")
    index_add("r.bp", "de", "0", "12",
        "Mathe/Integral/bestimmtes/Volumen/Zylinder oder Rotation")
    index_add("r.bp", "en", "0", "12",
        "maths/integral/defined/volume/cylinder or rotation")
    index_add("r.bq", "de", "0", "12",
        "Mathe/Integral/bestimmtes/Fläche/2 Polynome")
    index_add("r.bq", "en", "0", "12",
        "maths/integral/defined/area/2 polynomials")
    index_add("r.br", "de", "0", "12",
        "Mathe/Integral/unbestimmtes/x^n+Substitutionsregel")
    index_add("r.br", "en", "0", "12",
        "maths/integral/undefined/x^n and substitution rule")
    index_add("r.bs", "de", "0", "12",
        "Mathe/Integral/unbestimmtes/Substitutionsregel")
    index_add("r.bs", "en", "0", "12",
        "maths/integral/undefined/substitution rule")
    index_add("r.bt", "de", "0", "12",
        "Mathe/Integral/bestimmtes/Volumen/Rotation")
    index_add("r.bt", "en", "0", "12",
        "maths/integral/defined/volume/rotation")
    index_add("r.bu", "de", "0", "9",
        "Mathe/<NAME>/mit <NAME>")
    index_add("r.bu", "en", "0", "9",
        "maths/linear equation/with integers")
    index_add("r.bv", "de", "0", "11",
        "Mathe/Vektoren/Parallelogramm")
    index_add("r.bv", "en", "0", "11",
        "maths/vectors/parallelogram")
    index_add("r.bw", "de", "0", "11",
        "Mathe/Finanz/Zinsen/gemischt u. theoretisch")
    index_add("r.bw", "en", "0", "11",
        "maths/finance/interest/combined and theoretical")
    index_add("r.bx", "de", "0", "11",
        "Mathe/Trigonometrie/Fläche")
    index_add("r.bx", "en", "0", "11",
        "maths/trigonometry/area")
    index_add("r.by", "de", "0", "11",
        "Mathe/Trigonometrie/WSW")
    index_add("r.by", "en", "0", "11",
        "maths/trigonometry/asa")
    index_add("r.bz", "de", "0", "11",
        "Mathe/Trigonometrie/Steigung")
    index_add("r.bz", "en", "0", "11",
        "maths/trigonometry/slope")
    index_add("r.c", "de", "0", "11",
        "Mathe/Finanz/Rentenrechnung/unterjährig")
    index_add("r.c", "en", "0", "11",
        "maths/finance/annuity/monthly")
    index_add("r.ca", "de", "0", "11",
        "Mathe/Vektoren/2D")
    index_add("r.ca", "en", "0", "11",
        "maths/vectors/2d")
    index_add("r.cb", "de", "0", "11",
        "Mathe/Vektoren/Gerade")
    index_add("r.cb", "en", "0", "11",
        "maths/vectors/straight line")
    index_add("r.cc", "de", "0", "11",
        "Mathe/Vektoren/Transformation")
    index_add("r.cc", "en", "0", "11",
        "maths/vectors/transformation")
    index_add("r.cd", "de", "1", "10",
        "Mathe/Finanz/Zinsen")
    index_add("r.cd", "en", "1", "10",
        "maths/finance/interest")
    index_add("r.ce", "de", "1", "10",
        "Mathe/Funktionen/Log")
    index_add("r.ce", "en", "1", "10",
        "maths/functions/log")
    index_add("r.cf", "de", "1", "10",
        "Mathe/Funktionen/Funktionsgraph")
    index_add("r.cf", "en", "1", "10",
        "maths/functions/graph")
    index_add("r.cg", "de", "1", "11",
        "Mathe/Vektoren/Transformation und Inverse")
    index_add("r.cg", "en", "1", "11",
        "maths/vectors/transformation and inverse")
    index_add("r.ch", "de", "1", "10",
        "Mathe/Folgen und Reihen")
    index_add("r.ch", "en", "1", "10",
        "maths/sequences and series")
    index_add("r.ci", "de", "1", "9",
        "Mathe/Zahlen/NZQR lang")
    index_add("r.ci", "en", "1", "9",
        "maths/numbers/NZQR long")
    index_add("r.cj", "de", "1", "9",
        "Mathe/Zahlen/Kombination mit Operationen")
    index_add("r.cj", "en", "1", "9",
        "maths/numbers/combination with operations")
    index_add("r.ck", "de", "0", "13",
        "Mathe/Wahrscheinlichkeit/Lektor")
    index_add("r.ck", "en", "0", "13",
        "maths/probability/reviser")
    index_add("r.cl", "de", "1", "10",
        "Mathe/Stukturen/Gruppe")
    index_add("r.cl", "en", "1", "10",
        "maths/stuctures/group")
    index_add("r.cm", "de", "1", "10",
        "Mathe/Stukturen/Ring")
    index_add("r.cm", "en", "1", "10",
        "maths/stuctures/ring")
    index_add("r.cn", "de", "1", "9",
        "Mathe/Zahlen/Darstellung")
    index_add("r.cn", "en", "1", "9",
        "maths/numbers/representation")
    index_add("r.co", "de", "1", "9",
        "Mathe/abstrakt-konkret")
    index_add("r.co", "en", "1", "9",
        "maths/abstract-concrete")
    index_add("r.cp", "de", "1", "9",
        "Mathe/Mathe+Information")
    index_add("r.cp", "en", "1", "9",
        "maths/maths+information")
    index_add("r.cq", "de", "1", "9",
        "Mathe/Operationen")
    index_add("r.cq", "en", "1", "9",
        "maths/operations")
    index_add("r.cr", "de", "1", "9",
        "Mathe/Funktionen")
    index_add("r.cr", "en", "1", "9",
        "maths/functions")
    index_add("r.cs", "de", "1", "10",
        "Mathe/Morphismen")
    index_add("r.cs", "en", "1", "10",
        "maths/morphisms")
    index_add("r.ct", "de", "1", "11",
        "Mathe/Richtung")
    index_add("r.ct", "en", "1", "11",
        "maths/direction")
    index_add("r.cu", "de", "1", "12",
        "Mathe/Funktionen/Integral von 1÷z")
    index_add("r.cu", "en", "1", "12",
        "maths/functions/integral of 1÷z")
    index_add("r.cv", "de", "1", "12",
        "Mathe/Entropie")
    index_add("r.cv", "en", "1", "12",
        "maths/entropy")
    index_add("r.cw", "de", "1", "9",
        "Mathe/Informatik/Komplexität")
    index_add("r.cw", "en", "1", "9",
        "maths/informatics/komplexity")
    index_add("r.cx", "de", "1", "0",
        "Mathe/Externe Links")
    index_add("r.cx", "en", "1", "0",
        "maths/external links")
    index_add("r.cy", "de", "6", "10",
        "Mathe/Euler's Identität")
    index_add("r.cy", "en", "6", "10",
        "maths/euler identity")
    index_add("r.d", "de", "0", "12",
        "Physik/Elektrizität/Kondensator")
    index_add("r.d", "en", "0", "12",
        "physics/electricity/capacity")
    index_add("r.dg", "de", "3", "13",
        "Physik/Schaltkreise/Thevenin")
    index_add("r.dg", "en", "3", "13",
        "physics/circuits/thevenin")
    index_add("r.dh", "en", "3", "10",
        "physics/mechanics/forces")
    index_add("r.di", "de", "1", "9",
        "Mathe/Zahlen/C")
    index_add("r.di", "en", "1", "10",
        "maths/numbers/C")
    index_add("r.dj", "de", "1", "11",
        "Mathe/Trogonometrie")
    index_add("r.dj", "en", "1", "11",
        "maths/trigonometry")
    index_add("r.dk", "de", "1", "11",
        "Mathe/Funktionen/exponentiell")
    index_add("r.dk", "en", "1", "11",
        "maths/functions/exponential")
    index_add("r.e", "de", "6", "12",
        "Physik/Elektrizität/Kondensator")
    index_add("r.e", "en", "6", "12",
        "physics/electricity/capacitor")
    index_add("r.f", "de", "1", "12",
        "Mathe/Differential/trennbar")
    index_add("r.f", "en", "1", "12",
        "maths/differential/separable")
    index_add("r.g", "de", "0", "9",
        "Mathe/Lineare Gleichung/x im Nenner")
    index_add("r.g", "en", "0", "9",
        "maths/linear equation/x in denominator")
    index_add("r.h", "de", "0", "11",
        "Mathe/Vektoren/Matrix/Stufenweise Produktion")
    index_add("r.h", "en", "0", "11",
        "maths/vectors/matrix/stepwise production")
    index_add("r.i", "de", "0", "10",
        "Mathe/Funktionen/Funktionsgraphen")
    index_add("r.i", "en", "0", "10",
        "maths/functions/function graphs")
    index_add("r.j", "de", "0", "12",
        "Mathe/Integral/bestimmtes/sin,cos,exp,x^(-1)")
    index_add("r.j", "en", "0", "12",
        "maths/integral/defined/sin,cos,exp,x^(-1)")
    index_add("r.k", "de", "0", "12",
        "Mathe/Integral/bestimmtes/Polynom")
    index_add("r.k", "en", "0", "12",
        "maths/integral/defined/polynomial")
    index_add("r.l", "de", "0", "12",
        "Mathe/Integral/bestimmtes/quadratische Funktion")
    index_add("r.l", "en", "0", "12",
        "maths/integral/defined/quadratic function")
    index_add("r.m", "de", "0", "11",
        "Mathe/Finanz/Zinsen/Auf-, Abzinsen")
    index_add("r.m", "en", "0", "11",
        "maths/finance/interest/compound and discount")
    index_add("r.n", "de", "0", "11",
        "Mathe/Finanz/Investition")
    index_add("r.n", "en", "0", "11",
        "maths/finance/investment")
    index_add("r.o", "de", "0", "10",
        "Mathe/Lineare Gleichung/mit Brüchen")
    index_add("r.o", "en", "0", "10",
        "maths/linear equation/with fractions")
    index_add("r.p", "de", "0", "10",
        "Mathe/Log/mit Zahlen")
    index_add("r.p", "en", "0", "10",
        "maths/log/with numbers")
    index_add("r.q", "de", "0", "10",
        "Mathe/LGS/2x2")
    index_add("r.q", "en", "0", "10",
        "maths/linear system/2x2")
    index_add("r.r", "de", "0", "10",
        "Mathe/LGS/Kosten")
    index_add("r.r", "en", "0", "10",
        "maths/linear system/costs")
    index_add("r.s", "de", "0", "10",
        "Mathe/LGS/Mischen")
    index_add("r.s", "en", "0", "10",
        "maths/linear system/blending")
    index_add("r.t", "de", "0", "10",
        "Mathe/LGS/quadratische Kostenfunktion")
    index_add("r.t", "en", "0", "10",
        "maths/linear system/quadratic cost function")
    index_add("r.u", "de", "0", "10",
        "Mathe/Vektoren/Matrix/2x2 invertieren")
    index_add("r.u", "en", "0", "10",
        "maths/vectors/matrix/2x2 inversion")
    index_add("r.v", "de", "0", "9",
        "Mathe/Finanz/Prozentrechnung")
    index_add("r.v", "en", "0", "9",
        "maths/finance/percent")
    index_add("r.w", "de", "0", "9",
        "Mathe/Potenzen/mit Zahlen")
    index_add("r.w", "en", "0", "9",
        "maths/power/with numbers")
    index_add("r.x", "de", "0", "9",
        "Mathe/Potenzen/kürzen")
    index_add("r.x", "en", "0", "9",
        "maths/power/cancel")
    index_add("r.y", "de", "0", "9",
        "Mathe/Potenzen/Doppelbrüche")
    index_add("r.y", "en", "0", "9",
        "maths/power/compound fraction")
    index_add("r.z", "de", "0", "10",
        "Mathe/Quadratisch/Gleichung")
    index_add("r.z", "en", "0", "10",
        "maths/quadratic/equation")

available_langs = {'de',
 'en'}
<file_sep>/chcko/r/q/en.html
%path = "maths/linear system/2x2"
%kind = chindnum["problems"]
%level = 10

\[
\begin{matrix}
{{chiven.A[0][0]}} x & {{chutil.sgn(chiven.A[0][1])}} & {{abs(chiven.A[0][1])}} y & = & {{chiven.b[0]}} \\
{{chiven.A[1][0]}} x & {{chutil.sgn(chiven.A[1][1])}} & {{abs(chiven.A[1][1])}} y & = & {{chiven.b[1]}}
\end{matrix}
\]
%chq(chames=['x =','y ='])
<file_sep>/chcko/r/cq/de.rst
.. raw:: html

    %path = "Mathe/Operationen"
    %kind = chindnum["Texte"]
    %level = 9
    <!-- html -->

Eine grundlegende Operation ist die **Addition**.
Sie kann mengentheoretisch als Kardinalität der Summe zweier disjunkter Mengen gesehen werden:

    `|M\cup N|=|M|+|N|` wenn `M\cap N = \emptyset`

Dies abstrakte Vorstellung kann auf alle konkreten Fälle angewandt werden, wenn
man eine Ressourceneinheit (Länge, Gewicht,...) mit einem Element identifiziert
und es keine Überlappung gibt, weil etwa die Ressource nicht doppelt vergeben
werden kann.

Man muss im konkreten die reale physikalische Gegebenheit berücksichtigen.  So
addiert sich nicht die Länge von vertikal in ein Rohr eingeführte elastische
Stäbe wegen deren Elastizität und deren Gewicht.  Das Volumen zweier
Flüssigkeiten kann durchmischt aber kleiner als die Summe sein, weil die
Ressource Volumen in der Mischung effektiver zugeteilt werden kann.

Der **Multiplikation** begegnet man zuerst bei der Flächenberechnung eines Rechtecks:
Man kann entweder alle Kästchen zusammenzählen
(Addition) oder eine Wiederholung (Multiplikation) von Reihen oder eine
Wiederholung von Spalten darin sehen (Kommutativität von `\cdot`).  Wenn man
jedes Kästchen mit zwei Koordinaten `(i,j)` identifiziert, so zählt man mit der
Multiplikation die Kombinationen von `0 <= i <= a` und `0 <= j <= b` und erhält `a\cdot b`.

In einem Quadrat der Seitenlänge `a` hat man `a\cdot a` Einheitsquadrate, in
einem Würfel der Seitenlänge `a` hat man `a^3` kleine Würfel ...  Man zählt
hier Kombinationen einer Menge M `n` mal mit sich selbst.  `|M\times \dots
\times M| = |M|^n`. So kommt man zur **Potenz**.

- Die Multiplikation ist eine Kurzschreibweise der Addition.
  Man sagt auch sie ist 2. Stufe.

- Die Potenz eine Kurzschreibweise der Multiplikation.
  Man sagt auch sie ist 3. Stufe.

**Operation** ist ein anderer Name für eine **Funktion** (:lnk:`r.cr`),
wenn bestimmte Eigenschaften, wie **Assoziativegesetz** oder **Kommutativgesetz** erfüllt werden.
Eine **Operation** lässt sich gut mit einem Parameter zu einer neuen Menge {(Wert,Operation)}
vereinen (siehe Zahlen: :lnk:`r.ci` und `Lambda Kalkül <http://de.wikipedia.org/wiki/Lambda-Kalkül>`_)
Diese Mengen bestehen dann aus Anweisungen oder Vorgängen, oder besser **Operatoren**,
die dann auf etwas angewandt werden können. Z.B. 3m = (3,mal) Meter, d.h. 3 = (3,mal).

<file_sep>/chcko/r/a5/en.rst
.. raw:: html

    %path = "maths/differential/introduction"
    %kind = chindnum["texts"]
    %level = 12
    <!-- html -->

We will use the concepts:

- variable/value
- change
- velocity

Variable/Value
==============

English is a historical mix of two languages.
So there are two words of many things.
*Change*, for example, can also be called *vary*.
That's why something, that can change, is called a *variable*.

A variable assumes one *value* at a time, *exclusively*.
It does not need to be "at a time".
It could also be "at a place".

As a side-note:
The uniqueness is expressed by the word *function*:
We can say, the value is a *function* of this or that.

We can use a number to denote a *value*.
We could also use a word, but it is easier with a number.

Variable = {value1, value2, ...}
Position = {10m , 20m, ..., 120m, ...}

Change
======

We assume a gradual change.

Large changes:

    The change is expressed with a difference: `-`.
    Difference is abbreviated with a Greek D: Δ.

    `Δy_1 = y_1 - y_0`.

    The differences can be added to get the full extend of the variable.
    We basically undo the difference (subtraction) by addition.

    `y = Σ Δy_i = Δy_1 + Δy_2 + ...`.


Small changes:

    We use ``d`` instead of ``Δ`` for very small changes.

    `dy = (y + dy) - y`.

    `d` is called *differential*.

    With `dy` we use `∫` for sum,
    and call it *integral*.

Velocity
========

How fast a value changes is again a variable.
It is called *speed* or *velocity* of change of that variable.

Velocity is relative.
To describe velocity of change of the value of one variable
we need *another variable* to compare it to.
Often this other variable is *time*, but it could be something else.
If there is no other variable specified, then it is implicitly *time*,
or better our time feeling, given by how fast our brain thinks.

Lets find the velocity by which you grow.
We have two variables:

1) Height `y`: The distance from the floor to the top of your head.
2) Age `x`: The number of years that have passed since your birth.

Differences:

    The *average* velocity over `Δx` is found by *dividing* the differences:

    `\tilde{v} = Δy/Δx`

    Why *divide*?
    *Because* then you can *multiply* to get back the difference:

    `Δy = \tilde{v} Δx`

    And you can sum the differences to get back the height:

    `y = Σ Δy = Σ \tilde{v} Δx`

Differentials:

    This velocity is at a specific `x` because `dx` is so small that we can neglect it.

    `v = dy/dx`

    and to get back y we sum the very many `v dx`

    `y = ∫ dy = ∫ v dx`.

    Velocity is used if `x` is time.
    More generally, one calls it *derivative*:

    - *derivative* of height `y` with respect to age `x`

Summary
=======

Change is expressed via differences,

- that `Δ` means *difference*
- that `d` means very small difference or *differential*

The symbol for sum is

- `Σ`, if summing differences
- `∫`, if summing differentials

Velocity is a quotient between two differences

- average over `Δx`: `\tilde{v}=\frac{Δy}{Δx}`
- at `x`: `v=\frac{dy}{dx}`

<file_sep>/chcko/r/q/__init__.py
# -*- coding: utf-8 -*-

import numpy as np
import random

from chcko.chcko.hlp import Struct


def chiven():
    while True:
        A = np.array(random.sample(list(range(1, 19)) + list(range(-19, -1)), 4))
        A.shape = (2, 2)
        try:
            np.linalg.inv(A)
        except:
            continue
        break
    x = np.array(random.sample(list(range(2, 9)) + list(range(-9, -2)), 2))
    b = np.dot(A, x)
    A = A.tolist()
    b = b.tolist()
    g = Struct(A=A, b=b)
    return g


def chalc(g):
    iA = np.linalg.inv(np.array(g.A))
    x = np.dot(iA, np.array(g.b))
    return [i for i in x.round().tolist()]
<file_sep>/chcko/r/l/__init__.py
# -*- coding: utf-8 -*-

import random
import numpy as np
from chcko.chcko.hlp import Struct, norm_frac as chorm


def chiven():
    r = sorted(random.sample(list(range(-9, -1)) + list(range(1, 9)), 2))
    c = [-1, r[0] + r[1], -r[0] * r[1]]
    g = Struct(r=r, c=c)
    return g


def chalc(g):
    p = np.poly1d(g.c)
    p_i = np.polyint(p)
    I = p_i(g.r[1]) - p_i(g.r[0])
    return [I]
<file_sep>/chcko/r/dj/de.rst
.. raw:: html

    %path = "Mathe/Trogonometrie"
    %kind = chindnum["Texte"]
    %level = 11
    <!-- html -->

.. role:: asis(raw)
    :format: html latex

.. contents::

Im folgenden Diagramm hat der Kreis den Radius 1.
Die Länge des Bogens diese Einheitskreises ist ein Maß für den **Winkel**,
das **Bogenmaß** genannt wird und die Einheit ``rad`` (Radiant) besitzt.
Der rechte Winkel (90°) ist `\pi/2`.
Im Allgemeinen:

.. math::

    \frac{\pi}{180}\alpha[°] = \alpha[rad]

Wenn man den Winkel ändert, dann ändern sich auch die Längen, die mit
`\sin\alpha`, `\cos\alpha` und `\tan\alpha` beschriftet sind.
Diese Längen sind durch den Winkel bestimmt.
Anders gesagt: Diese Längen sind **Funktionen des Winkels**.

.. tikz:: \coordinate (O) at (0,0);
        \coordinate (C) at ({2*cos(60)},{2*sin(60)});
        \coordinate (P) at ({2*cos(60)},0);
        \coordinate (D) at (2,{2*tan(60)});
        \draw[black, very thin] (O) circle [radius=2];
        \draw[red,thick] (2,0) arc [radius=2, start angle=0, end angle=60] node[midway,above]{\tiny $\alpha$};
        \draw[blue,thick] (O) -- (C) node[midway,above]{\tiny $1$};
        \draw[blue,thick] (P) -- (C) node[midway,right]{\tiny $\sin\alpha$};
        \draw[blue,thick] (O) -- (P) node[midway,below]{\tiny $\cos\alpha$};
        \draw[green,thick] (P) -- (2,0);
        \draw[green,thick] (2,0) -- (D) node[midway,right]{\tiny $\tan\alpha$};
        \draw[green,thick] (C) -- (D);
        \draw[xshift=-1.1cm,yshift=-1cm] node[right,text width=2.2cm]
        { \tiny $\tan\alpha=\frac{\sin\alpha}{\cos\alpha}$\\$\sin^2\alpha+\cos^2\alpha=1$ };


.. admonition:: Ähnlichkeit = Affine Abbildung

    Man kann dieses Diagramm auf die Größe eines tatsächlichen rechtwinkligen
    Dreiecks skalieren und dieses Dreieck vollständig bestimmen, wenn man eine
    Seitenlänge und einen Winkel desselben weiß.

Die Graphen der obigen **trigonometrischen Funktionen** sind die folgenden


.. tikz:: \begin{axis}
        [
        ymin=-1,ymax=1,
        xmin=0,xmax=2*pi,
        xtick=\empty,
        ytick={-1,0,1},
        extra x ticks={1.5708,3.1416,4.712,6.2832},
        extra x tick labels={$\frac{\pi}{2}$, $\pi$, $\frac{3\pi}{2}$, $2\pi$},
        every extra x tick/.style={
                xticklabel style={anchor=north west},
                grid=major,
                major grid style={thick,dashed,red}
        },
        axis lines = center,
        xlabel=$x$,ylabel=$y$,
        enlargelimits=0.2,
        domain=0:2*pi,
        samples=100,
        axis equal,
        ]
        \addplot [green,thick] {tan(deg(x))} node [midway,left]{tan};
        \addplot [red,thick] {sin(deg(x))} node [above]{sin};
        \addplot [blue,thick] {cos(deg(x))} node [above]{cos};
    \end{axis}

Einige Werte der Funktionen ergeben sich durch Berechnungen am gleichseitigen Dreieck
(`\pi/3`, `\pi/6`) oder am Quadrates der Seitenlänge 1 (`\pi/4`).

`\cos` ist symmetrisch: `\cos(-\alpha)=\cos\alpha`

`\sin` ist antisymmetrisch: `\sin(-\alpha)=-\sin\alpha`.

Alle trigonometrischen Funktionen haben eine Periode von `2\pi`: `sin|cos|tan(\alpha+2\pi)=sin|cos|tan(\alpha)`.

Weil die spitzen Winkel eines rechtwinkligen Dreiecks sich zu `\pi/2` addieren, gilt

.. math::
    \sin(\pi/2 - \alpha)=\cos\alpha\\
    \cos(\pi/2 - \alpha)=\sin\alpha

<file_sep>/dodo.py
# -*- coding: utf-8 -*-
'''
doit utility::

Do this after having changed an RST file.
Start this from chcko-x/chcko/::

    $ doit -kd. html

Do this after having changed the header (path, kind, level) in a html or rst file::

    $ doit initdb

Do this after any changes, especially in the main code::

    $ doit test
    $ doit cov

Do this to add new content, html or rst::

    $ doit -kd. new
    $ doit -kd. newrst

task_included is internal.

'''

import sys
import os
chckouninstalled = os.path.normpath(os.path.join(os.path.dirname(__file__),'..','chcko'))
if os.path.exists(chckouninstalled):
    sys.path.insert(0,chckouninstalled)
from chcko.chcko import doit_tasks
doit_tasks.set_base(__file__)
task_included = doit_tasks.task_included
task_html = doit_tasks.task_html
task_initdb = doit_tasks.task_initdb
task_new = doit_tasks.task_new
task_newrst = doit_tasks.task_newrst
<file_sep>/chcko/r/t/__init__.py
# -*- coding: utf-8 -*-
import numpy as np
import random

from chcko.chcko.hlp import Struct


def chiven():
    cf = random.sample(range(2000, 2500), 1)[0]
    m1 = random.sample(range(30, 45), 1)[0]
    m2 = random.sample(range(50, 70), 1)[0]
    A = np.array([[m1 * m1, m1], [m2 * m2, m2]])
    x1 = random.sample(range(-5, -1), 1)[0]
    x2 = random.sample(range(300, 999), 1)[0]
    x = np.array([x1, x2])
    b = np.dot(A, x)
    c1 = b[0] + cf
    c2 = b[1] + cf
    g = Struct(A=A.tolist(), b=b.tolist(), cf=cf)
    return g


def chalc(g):
    iA = np.linalg.inv(np.array(g.A))
    x = np.dot(iA, np.array(g.b))
    x = x.tolist()
    return [i for i in (x + [g.cf])]
<file_sep>/chcko/r/cm/de.rst
.. raw:: html

    %path = "Mathe/Stukturen/Ring"
    %kind = chindnum["Texte"]
    %level = 10
    <!-- html -->

*Ringartige algebraische Strukturen* bauen auf
gruppenartige Strukturen (:lnk:`r.cl`) auf
und bestehen aus einer Menge `M` mit
zwei binären Verknüpfung `+` und `\cdot` , kurz `(M,+,\cdot)`.

- `(M,+)` und `(M,\cdot)` sind Monoide und es gilt `0\cdot a = 0`
  `\rightarrow` **Halbring**.

- `(M,+)` ist eine kommutiative Gruppe
  `\rightarrow` **Ring**.

- In `(M,\cdot)` gibt es keine zwei Zahlen, deren Produkt 0 ist.
  Nullteilerfrei `\rightarrow` **Integritätsring**.

- `(M\setminus\{0\},\cdot)` ist eine kommutative Gruppe
  `\rightarrow` **Körper**.

- `(M,\cdot)` erfüllt die Jakobi Identität `a\cdot (b \cdot c) + c\cdot (a \cdot b) + b\cdot (c \cdot a) = 0`
  `\rightarrow` **Lie Ring**.

- `(M,\cdot)` ist idempotent
  `\rightarrow` **Boolsche Algebra**.


<file_sep>/chcko/r/cb/en.html
%path = "maths/vectors/straight line"
%kind = chindnum["problems"]
%level = 11

The vector \(\begin{pmatrix}{{chiven.x[0]}}\\{{chiven.x[1]}}\end{pmatrix}\) is orthogonal
to the line \({{chiven.x[0]}}x_1{{chutil.sgn(chiven.x[1])}}{{abs(chiven.x[1])}}x_2={{chiven.b}}\).
The line can be described with the dot product
\(\begin{pmatrix}{{chiven.x[0]}}\\{{chiven.x[1]}}\end{pmatrix}\begin{pmatrix}x_1\\x_2\end{pmatrix} =
\begin{pmatrix}{{chiven.x[0]}}\\{{chiven.x[1]}}\end{pmatrix}\begin{pmatrix}v_1\\v_2\end{pmatrix}
={{chiven.b}}\).
<br>
\(v_1=0\)
<br>
\(v_2=\)
%chq()
<br>
Sketch
\(\begin{pmatrix}{{chiven.x[0]}}\\{{chiven.x[1]}}\end{pmatrix}\left(\begin{pmatrix}x_1\\x_2\end{pmatrix} -
\begin{pmatrix}v_1\\v_2\end{pmatrix}\right)
={{chiven.b}}\) für ein \(\vec{x}\not=\vec{v}\).

<file_sep>/chcko/r/v/__init__.py
# -*- coding: utf-8 -*-

import random

from chcko.chcko.hlp import Struct


def chiven():
    r, s = random.sample(range(1, 9), 2)
    m = random.sample(range(18, 21), 1)[0]
    u = random.sample(range(700, 900), 1)[0]
    g = random.sample(range(30, 50), 1)[0]
    e = 1.0 * u / (1 + g / 100.0)
    v = 1.0 * u * (1 - r / 100.0) * (1 - s / 100.0) * (1 + m / 100.0)
    g = Struct(r=r, s=s, m=m, v=v, e=e)
    return g


def chalc(g):
    u = g.v / (1 - g.r / 100.0) / (1 - g.s / 100.0) / (1 + g.m / 100.0)
    n = 100.0 * (u - g.e) / g.e
    return [u, n]
<file_sep>/chcko/r/r/__init__.py
# -*- coding: utf-8 -*-
import numpy as np
import random

from chcko.chcko.hlp import Struct


def chiven():
    A = np.array([1, 1] + random.sample(range(200, 1000), 2))
    A.shape = (2, 2)
    A = np.transpose(A)
    x = np.array(
        random.sample(
            range(
                500,
                1000),
            1) +
        random.sample(
            range(
                2,
                20),
            1))
    b = np.dot(A, x)
    g = Struct(A=A.tolist(), b=b.tolist())
    return g


def chalc(g):
    iA = np.linalg.inv(np.array(g.A))
    x = np.dot(iA, np.array(g.b))
    return [i for i in x.round().tolist()]
<file_sep>/chcko/r/ba/__init__.py
# -*- coding: utf-8 -*-

from random import randrange
from chcko.chcko.hlp import Struct, norm_rounded as chorm

__all__ = ['chiven', 'chorm', 'chalc', 'g_fn', 'g_fs']

g_fn = [lambda a1, q, n:a1 + (n - 1) * q, lambda a1, q, n: a1 * q ** (n - 1)]
g_fs = [lambda a1,
        q,
        n:n * (2 * a1 + (n - 1) * q) / 2,
        lambda a1,
        q,
        n: a1 * (q ** n - 1) / (q - 1)]


def chiven():
    rr = randrange(2)  # 0 arithmetic, 1 geometric
    if rr == 0:
        a1 = randrange(-9, 9)
        q = randrange(1, 9)
    else:
        a1 = randrange(-9, 9)
        q = 1.0 + (1.0 * randrange(1, 9) / 100)
    g = Struct(rr=rr, a1=a1, q=q, n=randrange(4, 9), N=randrange(20, 60))
    return g


def chalc(g):
    return [g_fn[g.rr](g.a1, g.q, g.n), g_fs[g.rr](g.a1, g.q, g.N)]
<file_sep>/chcko/r/x/__init__.py
# -*- coding: utf-8 -*-
import random
from sympy.abc import a, b, c, d, e, f, g, h, i, j, k, m, n, p, q, r, s, t, u, v, w, x, y, z
from sympy import sstr, simplify

from chcko.chcko.hlp import Struct, equal_0 as chequal

syms = [a, b, c, d, e, f, g, h, i, j, k, m, n, p, q, r, s, t, u, v, w, x, y, z]
syml = 'abcdefghijkmnpqrstuvwxyz'


def chiven():
    bn = random.sample(syml, 3)
    bd = bn[:]
    random.shuffle(bd)
    en = random.sample(range(-9, 9), 3)
    ed = random.sample(range(-9, 9), 3)
    g = Struct(bn=bn, bd=bd, en=en, ed=ed)
    return g


def chalc(g):
    nm = 1
    for i, ae in enumerate(g.en):
        nm = nm * simplify(g.bn[i]) ** ae
    for i, ae in enumerate(g.ed):
        nm = nm / simplify(g.bd[i]) ** ae
    return [sstr(simplify(nm))]

chorm = lambda x: x
<file_sep>/chcko/r/d/de.html
%path = "Physik/Elektrizität/Kondensator"
%kind = chindnum["Übungen"]
%level = 12

%include('r.e')
<br>
a) Wie hängt die Ladung Q von der Zeit t ab?
\(Q(t)=\)
%chq(0)
<br>
Der Widerstand, über den die Ladung abfließt, ist R={{chiven.r}}\(k\Omega\).
Zum Zeitpunt t=0s misst man am Kondensator eine Spannung von {{chiven.u}}V,
und bei t={{chiven.t}}s ist die Spannung {{round(chiven.u2,2)}}V.
<br>
b) Bestimme die Kapazität des Kondensators? \(\frac{C}{μF}=\)
%chq(1)
<br>
c) Wie groß ist die Ladung bei t=0s? \(\frac{Q_o}{As}=\)
%chq(2)
<br>
d) Wie groß ist die Ladung bei t={{chiven.t}}s? \(\frac{Q_t}{As}=\)
%chq(3)
<br>
e) Nach wieviel Sekunden ist der vollgeladene Kondensator nur mehr halbvoll?
%chq(4)
<file_sep>/chcko/r/bx/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from math import pi, sin, cos
from chcko.chcko.hlp import Struct


def chiven():
    c = randrange(4, 20)
    alpha = randrange(10, 80)
    g = Struct(c=c, alpha=alpha)
    return g


def chalc(g):
    res = 0.5 * sin(pi * g.alpha / 180) * cos(pi * g.alpha / 180) * g.c ** 2
    return [res]
<file_sep>/chcko/r/dg/de.rst
.. raw:: html

    %path = "Physik/Schaltkreise/Thevenin"
    %kind = chindnum["Beispiele"]
    %level = 13
    <!-- html -->

.. role:: asis(raw)
    :format: html latex


Wir werden die Übertragungsfunktion eines Bandsperre-Filters mit der Methode von Thevenin ermitteln.

Wir ziehen dazu einen Schaltkreis aus
`Op Amps for EveryOne (5-10) <http://www.ti.com/lit/an/slod006b/slod006b.pdf>`_.
heran.

.. texfigure:: r_dg_c1.tex
      :align: center

Das Eingangssignal ist gegenüber Erde. Wir zeichnen die Schaltung neu, um das widerzuspiegeln.

.. texfigure:: r_dg_c2.tex
      :align: center

Wir suchen `G=\frac{V_o}{V_i}`.
`V_o` ist die Spannung beim rechten Widerstand. Wir werden dort das Thevenin-Äquivalent berechnen.


.. texfigure:: r_dg_c3.tex
      :align: center

Wir finden die Ströme mittels der Kirchhoff'schen Regeln.
Es gibt zwei Schleifen, wo Strom fließt.
Es gibt keinen Strom bei dem Widerstand, wo wir den Stromkreis geöffnet haben.

.. texfigure:: r_dg_c4.tex
      :align: center

Die resultierenden Gleichungen sind

.. math:: \begin{array}{l l l}
    V_i - I_2 R - \frac{I_2}{iwC} - I_1 R & = 0\\
    V_i - \frac{I_1 - I_2}{iwC} - I_1 R & = 0
    \end{array}

Diese lösen wir nach `I_1` und `I_2`:

.. math:: \begin{array}{l l}
    I_1 &= \frac{\omega C V_i (-2 i+C R \omega)}{-1-3 C R i \omega+C^2 R^2 \omega^2}\\
    I_2 &= -\frac{i \omega C V_i}{-1-3 C R i \omega+C^2 R^2 \omega^2}
    \end{array}

Bei die kleine Schleife bei `V_{th}` berechnen wir mit den bekannten Strömen

.. math:: V_{th}=\frac{I_2}{iwC} + I_1 R

Als nächstes brauchen wir die Thevenin-Impedanz. Dafür entfernen wir `V_i`
und berechnen die Impedanz wie sie von `V_{th}` aus gesehen wird.

.. texfigure:: r_dg_c5.tex
      :align: center

Wir zeichnen die Schaltung neu, um besser zu sehen, was parallel und was seriell ist.

.. texfigure:: r_dg_c6.tex
      :align: center

Dann erhalten wir

.. math:: Z_{th}=\left(\frac{1}{i \omega C}+\frac{R \frac{1}{i \omega C}}{R+\frac{1}{i \omega C}}\right) || R =
    \frac{R (1+2 i \omega C R)}{1+3 i \omega C R - C^2 R^2 \omega^2}

und

.. math:: V_o = \frac{R}{R + Z_{th}}

Und endlich bekommen wir die **Übertragungsfunktion**:

.. math:: G = \frac{V_o}{V_i} = \frac{(-i+C R \omega)^2}{-2-5 i \omega C R+C^2 R^2 \omega^2}
    = \frac{(1+i \omega C R)^2}{2+5 i \omega C R-C^2 R^2 \omega^2}
    = \frac{(1+ s\tau)^2}{2+5 s\tau+(s\tau)^2}

Hier haben wir `\tau=R C` und `s=i \omega` gesetzt, wie es für Filter üblich ist.
Beim Nenner kann man für `s\tau` die Nullstellen berechnen (-4.56,-0.44).
Das Produkt der Nullstellen ist 2. `G` können wir damit so schreiben

.. math:: G = \frac{(1+ s\tau)^2}{2(1+\frac{s\tau}{0.44})(1+\frac{s\tau}{4.56})}

<file_sep>/chcko/r/bc/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from math import log
from chcko.chcko.hlp import Struct, norm_frac as chorm


def chiven():
    g = Struct()
    g.C0 = randrange(20, 100) * 1000
    g.i = randrange(20, 40) / 10.0
    g.n = randrange(5, 10)
    g.r = randrange(300, 400)
    return g


def chalc(g):
    q = (g.i / 100.0 + 1) ** (1.0 / 12)
    m = 12 * g.n
    Q = lambda n: q * (q ** n - 1) / (q - 1)
    monthlyrate = g.C0 * q ** m / Q(m)
    mm = -log(1 - g.C0 * (q - 1) / q / g.r) / log(q)
    fullmonths = int(mm)
    Cfullrate = g.r * Q(fullmonths)
    restrate = g.C0 * q ** fullmonths - Cfullrate
    restrate = q * restrate
    return [monthlyrate, fullmonths, restrate]
<file_sep>/setup.py
import os
import io
import setuptools
from pathlib import Path

package_root = os.path.abspath(os.path.dirname(__file__))

# # maybe not all installed in system
# # done in Makefile
# from doit.cmd_base import DodoTaskLoader
# from doit.doit_cmd import DoitMain
# def doit_run():
#     loader = DodoTaskLoader()
#     loader.setup(
#             dict(
#             dodoFile=os.path.join(package_root,'dodo.py')
#             ,cwdPath=os.path.join(package_root,'chcko','r')
#             ,seek_file=True
#                  ))
#     DoitMain(loader).run(['-kd.', 'html'])
#     DoitMain(loader).run(['-kd.', 'initdb'])

def main():
    # doit_run()
    os.chdir(package_root)
    try:
        import shutil
        shutil.rmtree('build')
    except:
        pass
    proot = Path(package_root)
    readme_filename = os.path.join(package_root, "README.rst")
    with io.open(readme_filename, encoding="utf-8") as readme_file:
        readme = readme_file.read()
    setuptools.setup(
        name="chcko-r",
        version = "1.3.2", # keep same a chcko
        description="A random mix of exercises for chcko",
        long_description=readme,
        long_description_content_type="text/x-rst",
        author="<NAME>",
        author_email="<EMAIL>",
        url="https://github.com/chcko/chcko-r",
        classifiers=[
            "Development Status :: 4 - Beta",
            "Intended Audience :: Developers",
            "Programming Language :: Python",
            "Programming Language :: Python :: 3",
            "Programming Language :: Python :: 3.7",
            "Programming Language :: Python :: 3.8",
            "Operating System :: OS Independent",
            "Topic :: Internet",
            "License :: OSI Approved :: GNU General Public License (GPL)",
            "Topic :: Education",
            "Topic :: Education :: Computer Aided Instruction (CAI)"
        ],
        packages=setuptools.find_namespace_packages(),
        include_package_data=True,
        namespace_packages=["chcko"],
        install_requires=['schemdraw','pint'],#don't ["chcko"], because on gcloud chcko is uploaded and not installed
        extras_require={},
        zip_safe=False,
    )

if __name__ == "__main__":
    main()
<file_sep>/chcko/r/u/__init__.py
# -*- coding: utf-8 -*-

import numpy as np
import random

from chcko.chcko.hlp import Struct, norm_frac as chorm


def chiven():
    while True:
        A = np.array(random.sample(range(-5, 6), 4))
        A.shape = (2, 2)
        try:
            m = np.linalg.inv(A)
            A = np.linalg.inv(np.array(m))
        except:
            continue
        break
    g = Struct(m=m.tolist())
    return g


def chalc(g):
    A = np.linalg.inv(np.array(g.m))
    A = A.round()
    r = [A[0, 0], A[0, 1], A[1, 0], A[1, 1]]
    return [i for i in r]
<file_sep>/chcko/r/a1/en.rst
.. raw:: html

    %path = "physics/S=E*t"
    %kind = 1
    %level = 12
    <!-- html -->

A system can be seen as one variable.
A system *state* is a *value* of the variable.

**Entropy** is the information of a variable.
Entropy is the *number of values* of the variable.

What value (or state) means is of no importance.
It has been abstracted away.
Only the number counts here.

The values must actually occur.
An elementary change is a value selection.
**Energy** is the *number of values per time*.

.. math::

        S = Et

One can see it the other way around:
Energy brings time into existence by the selections of values.
If the system is composed of many independent variables,
this produces a system time resolution,
that does not exist in any of the independent variables.

A constant amount of energy can either result in

- a few states cycling fast: `\Delta S` and `\Delta t` small
- a lot of states cycling slow: `\Delta S` and `\Delta t` large

A system often consists of layers.

Assuming an ideal gas,
the energy `Q=TS` is given by:

- the temperature `T`: the average kinetic energy of one particle
- the entropy `S`

This divides the system in two layers:

- `T` encodes information events (energy) of a layer below.
- `S` counts the events in the current layer.

The logarithm in entropy comes up,
when we distribute the information
to more variables of the same kind (e.g. the bit).
In the other direction this is the reason for the exponent `e^S`.

The particle's direction of motion partitions the number `N` of particles

- by direction: factor `1/2`, since exclusive
- by orientation: factor `3`,
  since `T`, through averaging,
  is acting on all three orientations simultaneously

Therefore:

.. math::

    Q = ST = 3/2NkT = 3/2RT = 3/2pV

For an ideal gas the inner energy is equal to the work done on the surrounding `3/2 pV`.

The average energy per particle `E` is:

.. math::

    E = 1/2 m v^2 = 3/2 kT

Boltzmann's constant `k` is a conversion factor of units of energy.
`v^2` can be related better to micro events per time than `T`,
but also `E` is only the energy in that layer and not the ultimate
unit of information event per time.

The ultimate information event is given by the Planck constant.
The sum of all such events create space and time: E-t, x-v, ...

<file_sep>/chcko/r/di/en.rst
.. raw:: html

    %path = "maths/numbers/C"
    %kind = chindnum["texts"]
    %level = 10
    <!-- html -->

.. contents::

The Complex Numbers `\mathbb{C}`
--------------------------------

The real numbers (:lnk:`r.ci`) are more than just a count.

- There is also direction (`+` or `-`). Now we will extend this to all directions in a plane.

- In `\mathbb{R}`` we invert the direction with multiplication by `-1`. We extend this to rotation to any direction.

In `\mathbb{R}` `x^2` only assumes positive values. The equation `x^2+1=0` does not have a solution.

So we invent a "number" `i` that satisfies `i^2=-1`.

`i` is called **imaginary unit** and its multiples are called imaginary
numbers. `i` is like apple or orange. It has nothing to do with
the unit `1`. The imaginary numbers are orthogonal to `\mathbb{R}`,
which means you can choose from these two sets independently.
All combinations form a 2-dimensional space,
i.e. a plane, the **complex plane**.

    `z = a + ib \in \mathbb{C}`

is also a two-dimensional vector: 2 orthogonal directions that can be added independently.

There are two representations

- `z = a+ib`, i.e. via the components or
- `z = r(\cos\varphi + i\sin\varphi)` via modulus `r` and artument `\varphi` (angle, phase) in radiants.

Now consider the following:

- `i\cdot 1 = i`, i.e. multiplication with `i` make 1 to `i`, which is orthogonal to 1,
  the **real unit**. This is a rotation by a right angle.
- `i\cdot i = -1`. Again a rotation by a right angle.

Generally: Multiplication with `i` produces a rotation by the right angle.

Since two multiplications (`x^2`) are supposed to invert (rotate by `\pi`)
one multiplication should rotate by half of it (`\pi/2`).

When multiplying exponentials, the exponent gets added.
This gives a hint that there could be a representation that has the angle in the exponent.

In trigonometric addition formulas (e.g. `\cos(\alpha+\beta)=\cos\alpha\cos\beta-sin\alpha\sin\beta`),
multiplication adds the angles.

Finally developing `\sin` and `\cos` into a Taylor series and comparing with the `e^x` series
leads to the **Euler Formula**:

- :inl:`r.cy`

`z=re^{i\varphi}` is a usual way to represent complex numbers.

About `\sin` and `\cos` we know that the period is `2\pi`, therefore this is
true for `e^{i\varphi}`.  The nth root divides the period up to `2n\pi` to
below `2\pi` and so we have `n` different roots.

.. math::

    z^{1/n}=r^{1/n}e^{i(\varphi/n+2k\pi/n)}

More generally:

   In `\mathbb{C}` every polynomial of degree n has exactly n roots
   (**fundamental theorem of algebra**), if one counts the multiplicity
   of roots. `\mathbb{C}` therefore is called **algebraically closed**.

This means that not only `x^2`, but every polynomial maps the whole
`\mathbb{C}` to the whole of `\mathbb{C}`.

.. admonition:: Note

    In function theory one learns that this can be extended to all functions
    that are infinitely often differentiable (analytic or holomorphic) in all of `\mathbb{C}`
    (entire functions), because they can be developed into a Taylor series.

Further properties:

- a = Re(z) is the real part

- b = Im(z) is the imaginary part

- `\bar{z}=re^{-i\varphi}=a-ib` is the complex conjugate of z. `\bar{z^n}=\bar{z}^n`.

  `z_1\bar{z_2}` combines in itself dot product (`Re(z_1\bar{z_2})=r_1r_2\cos\Delta\varphi`)
  and vector product (`Im(z_1\bar{z_2})=r_1r_2\sin\Delta\varphi`).

- `|z| = \sqrt{z\bar{z}} = \sqrt{a^2+b^2} = r` is the absolute value (modulus) of z.

  The square over the length of a complex number independent of direction
  is given by `z\bar{z}` and not by `z^2`.

- `φ = arg(z)` is the argument (phase) of z.

  - `arg(z_1z_2)=arg(z_1)+arg(z_2)`

  - `arg(\frac{z_1}{z_2})=arg(z_1)-arg(z_2)`

Applications for `\mathbb{C}`
-----------------------------

Since `\mathbb{C}` is a extension of `\mathbb{R}`,
one can do everything with `\mathbb{C}` that you can do with `\mathbb{R}`.
The essentially new is that `\mathbb{C}` includes all directions not just `+` and `-`.

What is a direction?

:inline:`r.ct`

The complex numbers are used in physics and technology in connection with vibrations and waves
and there are many of them:

- mechanics/solid state physics: water waves, acoustic waves, elastic waves, ...

- Electricity: alternate current, alternate current circuits (resistance, capacity and inductance),...

- Electrodynamics: Electromagnetic waves (light, radio), ...

- Optics: Light, ...

- Quantum dynamics: particle waves, ....

Basically applications of complex numbers are due to

- the fact that unrestricted calculation is possible in `\mathbb{C}` and

- further results in function theory.

Many physical systems are described with differential equations.
These can be reduced to polynomial and then one gets complex numbers as roots.


<file_sep>/chcko/r/bu/__init__.py
# -*- coding: utf-8 -*-
from random import sample
from chcko.chcko.hlp import Struct, norm_int as chorm


def chiven():
    a, c = sample(list(range(2, 9)) + list(range(-9, -2)), 2)
    x = sample(list(range(2, 9)) + list(range(-9, -2)), 1)[0]
    b = (c - a) * x
    g = Struct(a=a, b=b, c=c)
    return g


def chalc(g):
    res = g.b / (g.c - g.a)
    return [res]
<file_sep>/chcko/r/h/en.html
%path = "maths/vectors/matrix/stepwise production"
%kind = chindnum["problems"]
%level = 11

For the production of a product X it needs {{chiven.A[1][0]}} W(orking hours), {{chiven.A[1][1]}} P1 (Part 1)
and {{chiven.A[1][2]}} P2.
For the production of a product Y it needs {{chiven.A[2][0]}} W, {{chiven.A[2][1]}} P1
and {{chiven.A[2][2]}} P2.
A product Z needs {{chiven.Z[0]}} W and {{chiven.Z[1]}} X and {{chiven.Z[2]}} Y.<br>
Make a matrix equation and determine, how much the production of
{{chiven.m}} Z costs (K), if the costs of the needed resources are
W={{chiven.k[0]}}, P1={{chiven.k[1]}}, P2={{chiven.k[2]}}.<br>
K =
%chq()

<file_sep>/chcko/r/cg/en.rst
.. raw:: html

    %path = "maths/vectors/transformation and inverse"
    %kind = chindnum["texts"]
    %level = 11
    <!-- html -->


Coordinate Transformation and Inverse Matrix
============================================

Though convenient it is not a necessity that the basis vectors are independent,
i.e. orthogonal.

As an example think of ingredients of cakes as a vector space (*ingedient vector space*).
Then every cake is a vector, an independent choice from more variables,
which in this case are the quantities for each ingredient (0 for not used at all).

The ingredients can be regarded orthogonal to each other. The context does not
ask for a detailed comparison. *The dot product is 0.*

Let's compare the cakes in detail though via their ingredients.
Cake A and cake B surely have ingredients in common.
So the unit vectors in the *cake vector space* are not orthogonal to each other
with this comparison. *The scalar product is not 0.*

A vector in the cake vector space (How many of each type of cake?) can be transformed
to the ingredient vector space by multiplying with a matrix.
Every column in the matrix is the recipe of one cake.

In a matrix and vector written as a set of numbers, every number means
something.  What it means is coded by the position the number takes.  This is
called position coding. The same we do with our number system where the units,
the tens, the hundreds,... have their own position.

In this example the cake space and ingredient space do not necessarily need to
have the same number of variables (number of variables = dimension).
We can have 10 ingredients and
3 types of cakes. Then the transformation matrix is 10x3 (10 rows, 3 columns).
Such a `m\times n` matrix with `m\not = n` cannot be inverted,
i.e. one cannot infer from the ingredients how many of each type of cake are baked.
Said differently: Not for every combination of ingredients there
is a combination of cakes (linear combination), which needs exactly that amount of ingredients.

If we fix a number for each cake in a smaller assortment of cakes
we use less information, i.e. we make fewer decisions,
than in the bigger space of ingredients.

.. admontition:: Pseudoinverse

    A non-square matrix can be pseudo-inverted, though: Moore-Penrose Pseudoinverse.
    For this example multiplying an ingredient vector with the pseudo-inverse
    would produce a cake vector, which minimizes unused quantities of ingredients
    (Method of Least Squares) or makes best use of the ingredients (Maximum Entropy Method).

If we change from one vector space to another with same dimensions,
then we can get back to the starting one by multiplying with the *inverse matrix*.

In order for the inverse to exist, in addition to being square, the
columns/rows of the matrix must be *linearly independent*.  If not, then that
is like effectively being in a smaller matrix (*rank of matrix*). For the
cake example this means that every type of cake must have a different combination of
ingredients, which is some extra information that distinguishes it from the
others and that can be used to code something.

.. admonition:: Linear Independence

    A square matrix can be inverted, if columns (rows) cannot be expressed as
    linear combination of the others, i.e. the rank of the matrix is equal to
    its dimension.

One can calculate the inverse of a square Matrix by:

- leaving out the `ij` cross and calculate the determinant = Minor `M_{ij}`
- change the sign, if `i+j` is odd
- transpose, i.e. mirror at the main diagonal
  (compare below: `ij` for `A` and `ji` for `M`)
- divide everything by the determinant

Short:

.. math::

    (A^{-1})_{ij} = \frac{1}{det(A)}(-1)^{i+j} M_{ji}


Normally we write `\frac{1}{det(A)}` in front of the matrix,
but it can be multiplied with every number of the matrix.

For a *2x2 Matrix* `M_{ij}` is the diagonally opposite number.  Because of the
transposing the numbers left bottom and right top (secondary diagonal) stay
where they are, but the sign changes.  At the main diagonal the numbers get
swapped, but since `i+j` is even the sign does not change.

- Main diagonal `\rightarrow` sign stays
- Secondary diagonal `\rightarrow` position stays

<file_sep>/chcko/r/cp/en.rst
.. raw:: html

    %path = "maths/maths+information"
    %kind = chindnum["texts"]
    %level = 9
    <!-- html -->

Computer and Mathematics
------------------------

We humans process information and also have abstracted the rules
by which this is done. The result is mathematics.

The computer processes information by applying these rules.
It can even be used to find new rules, new paths, new proofs.

Computer science in this sense is a part of mathematics,
now with many extensions which are specifically applicable
to the computers of our times.

Since we have the computer now,
we will not only let it calculate,
but gradually use it for all kinds of formalized thought processes.
Autonomous learning, abstracting and synthesizing (creativity),
can also be taken over by computers,
although still in its infancy.

The computer not only makes calculations unbelievably fast,
but has the potential to take over most of the thought tasks,
we humans are capable of.

Mathematics deals with information processing.
But what is that?

Information
-----------

The communication between two humans, in which information is exchanged,
can be broken down to an elementary process.

This process consists of

- a set, one can choose elements from (choice)
- the choosing process (decision, ...)

The selection is a repeated process.
All selections make up a **mapping**.
An element can be chosen exclusively only, and every element gets its turn.

.. admonition:: Note

    The smallest set one can still choose from has 2 elements.
    That is why the **bit** is the smallest unit of information.

The sender chooses concepts in his head, maps them to words,
maps them to phonetic combinations or sign combination and sends
them over a medium (air, paper) to the receiver.
The receiver processes in the opposite direction.

Phonemes, letters and digits are there to create a multitude (words, numbers)
to which concepts can be mapped (coding).

.. admonition:: Note

    With numbers one can choose everything
    one can choose with words. One way is to put all concept into a
    sequence and let the number choose the position.
    Words in our brain are used associatively,
    but that is possible with numbers, too.

Basically all dynamic systems function with the above elementary selection processes.
There are always sets and choices.

Examples:

- Biology: Variants via mutation and selection through the natural environment,
  i.e. the other individuals and the habitat.
- Economy: supply and demand
- Society: organizations and their success
- Politics: politicians and voters
- Science: theories and their usefulness to describe phenomena
- Ideas and their supporters
- random thoughts in our brain and checking via experience stored in the brain
- ...

Since quantum mechanics we know that randomness is an inherent principle of nature,
that not everything is predetermined, but that selection processes do really
create new combinations, fleeting ones and staying ones.

Nature processes information by distributing states
The universe can thus be compared with living systems like us.
Both function with the same abstract principle of information processing.

Energy, Entropy
...............

:inline:`r.cv`

:inline:`r.a1`

Mathematics and Information
---------------------------

We have recognize the elementary process of information (transport) to
be the selection which consists of

- set
- choosing

Let's connect this better with mathematics?

Sets and Variables
..................

The set we find in the set theory, the foundation of mathematics.

To choose elements from a set one can reserve a bit for every element
and code a selection via 0 (not used) and 1 (used).
One can do with less bits, if one first finds out, which elements
exclude each other.

A set from which an element is chosen exclusively, is a variable.
The element is the value.

.. admonition:: Variable

    Variablen bestehen aus Werten.

With variable we mean the real thing, not a placeholder for a number.
Only via a mapping, e.g. by comparing to a unit, the value is linked to a
number (coordinate).

Mathematics describes reality by finding variables
and then dependencies between them.

Strukture
.........

An important aspect of information processing is abstraction.  By comparing one
finds common patterns and these are used to build a smaller encoding
(description) and to recognize later.  In programming there is an important
guideline: Don't Repeat Yourself (DRY).  That's how mathematics does it as
well. Patterns that repeat are described abstractly and concrete objects become
examples of these structures (group, ring, field, ...).

This makes information exchange (communication) more effective. Instead of
repeatedly describe, e.g. the rules for `+` in `\mathbb{Z}` and `V` and so on
one can say `(\mathbb{Z},+)` and `(V,+)` and so on are groups.

Mathematics as science builds a structure as a whole by successively adding new
concepts and theorems.  New works build on these concepts, choose what to work
on, and thus extend the structure.

.. admonition:: Struktur

    This successive extension and sophistication of structure
    is a general developement of dynamic systems (evolution):
    biological evolution, economy, ... (see above).

    In order for complex and lasting structure to develop
    energy must be supplied in the right dosage.
    For the economy this is the money.


Algorithmics
............

To determine (choose) a value of a variable, mathematics uses the **function**.
This is also the name in informatics, but with a slightly different meaning,
Other names are subprogram, subroutine, procedure, ...

:inline:`r.cw`

The value of one variable can depend on the values of more other variables.
Function therefore have more parameters. They are called **formal parameters**
in the definition of the function.  A first selection process there is already
when choosing the **actual parameters** to correspond to the formal ones when
calling the function.

Functions in programming languages do not necessarily return the value of a variable,
but it is a good design to name variables and the elementary
dependencies via functions in order to clearly separate them from others.

Functions consist of calls to other functions

- Successive calls are a **sequence**.
- Decisions, which calls to do under which conditions, are **branches**.
- Repeated execution of blocks of calls are a **loop**

This algorithmics is hidden everywhere in mathematics behind numbers,
expression and symbols (polynomials, `\sqrt{}`, `\lim`, `\int`, ...) in
theorems and proofs.  The whole of mathematics can be regarded as a huge
program, but unfortunately still most of it in a language that the computer
does not understand.

.. admonition:: Representation

    A big challenge is to convert the representation of mathematics
    into a language the computer can understand.
    There are many computer languages, some especially made for mathematics.

    Many different representations increase the effort
    and reduce the applicability.

    The same is true for human languages.


.. admonition:: Numbers

    When introducing the number systems algorithmic aspects are combined
    with the count (the natural number):

    - Count with + and -: Integers

    - Count with * and /: Rationals

    Then we can regards

    - Numbers as elementary instruction (add 2, subtract 2, ...)

    - analytic expressions as programs/functions

    - term simplification as program simplification, profiling


.. admonition:: Equations

    The equation is a function that returns the result of a comparison.
    Equivalent transormations of an equation is a kind of profiling, too.

    Equations and inequalities are used to implicitly define sets.


<file_sep>/chcko/r/bj/__init__.py
# -*- coding: utf-8 -*-
import random
from math import log
from chcko.chcko.hlp import Struct


def chiven():
    g = Struct()
    g.pc = random.randrange(10, 90)
    return g


def chalc(g):
    t = -log(g.pc / 100.0) * 5730 / log(2)
    return [t]

#import sympy
#from sympy.abc import x
#th = 5730
# lambda = sympy.ln(2)/th
# lambda.n()
# c14 = sympy.exp(-lambda*x)
#nc14 = lambda v:sympy.N(c14.subs(x,v))
# nc14(5730)
#t = -log(g['pc']/100.0)*5730/log(2)
#
<file_sep>/chcko/r/ch/de.rst
.. raw:: html

    %path = "Mathe/Folgen und Reihen"
    %kind = chindnum["Texte"]
    %level = 10
    <!-- html -->


Folgen und Reihen
-----------------

Eine **Folge** ist eine Funktion der natürlichen Zahlen.

Die natürliche Zahl ist eine Methode, um auf die Glieder der Folge zu verweisen.
Sie heißt auch Index.

- `a_1` ist das erste Glied der Folge
- `a_2` ist das zweite Glied der Folge
- ...
- `a_n` ist das n-te Glied der Folge

Werden die ersten n Glieder einer Folge aufsummiert,
dann ist das das n-te glied der Summenfolge oder **Reihe**.

Der Begriff *Funktion* bedeutet:
Weiß ich das wievielte Glied, dann weiß ich die Zahl dort.

Viele Folgen haben eine Regelmäßigkeit, die es erlaubt sie viel kürzer zu beschreiben
(Kurze Beschreibung = geringe Komplexität).

arithmetische Folge
...................

Bei der arithmetischen Folge ergibt sich ein Glied der Folge aus dem
vorhergehenden durch Addieren einer gleichbleibenden Zahl.

`a_{n+1} = a_n + d`.

Das ist die **rekursive** Darstellung der arithmetischen Folge.

Um zum n-ten Glied zu kommen, wiederholt man das n-1 mal:

`a_n = a_1 + (n-1) d`

Das ist die **Termdarstellung** der arithmetischen Folge.

.. admonition:: Hinweis

    In vielen Programmiersprachen wird bei 0 gestartet, da man dann `nd` hat, statt `(n-1)d`.

Um eine gegebene Folge als arithmetische Folge zu erkennen, schaut man, ob die
Differenz aufeinanderfolgender Glieder gleich bleibt.

arithmetische Reihe
...................

Betrachtet man die Summe die ersten n Glieder, dann kann man eine Regelmäßigkeit erkennen,
und solche sind immer Anlass für einfachere Berechnungsmethoden.

Betrachtet man obige Termdarstellung, kann man erkennen, dass wenn man vom
Anfang der Folge startet immer d dazu kommt, wenn man aber vom letzten (n-ten)
Glied der Folge rückwärts geht immer d wegkommt. Diese Operationen heben sich auf.
Man kann deshalb Anzahl/2 mal die Summe vom ersten und letzten Glied machen.

`\sum_{k=1}^{n} a_k = \frac{n(a_1+a_n)}{2}`

Insbesondere ist `1+2+...n=\frac{(n+1)n}{2}`.


geometrische Folge
...................

Bei der geometrischen Folge ergibt sich ein Glied der Folge aus dem
vorhergehenden durch Multiplikation mit einer gleichbleibenden Zahl.

`a_{n+1} = a_n \cdot q`.

Das ist die **rekursive** Darstellung der geometrischen Folge.

Um zum n-ten Glied zu kommen, wiederholt man das n-1 mal:

`a_n = a_1 q^{n-1}`

Das ist die **Termdarstellung** der geometrischen Folge.

Um eine gegebene Folge als geometrisch zu erkennen, schaut man, ob der
Quotient aufeinanderfolgender Glieder gleich bleibt.

geometrische Reihe
...................

Betrachtet man

.. math::

    \begin{matrix}
    1+&q+q^2+...+q^{n-1}&=&S_n\\
      &q+q^2+...+q^n&=&q S_n\\
    \end{matrix}

so sieht man, dass viele Summanden gleich sind. Durch Subtraktion erhält man

`\sum_{k=1}^{n} q^{k-1} = 1 + q + ... + q^{n-1} = \frac{q^n-1}{q-1}=\frac{1-q^n}{1-q}`

<file_sep>/chcko/r/a0/de.rst
.. raw:: html

    %path = "Mathe/Vektoren"
    %kind = chindnum["Texte"]
    %level = 11
    <!-- html -->

Wenn man die Zutaten von einer Auswahl von Kuchenrezepten als Vektorraum auffasst,
dann ist jeder Kuchen `z` ein Vektor im *Zutatenvektorraum*,
d.h. wir wählen unabhängig für jede Zutat (Variable `z_i`).
Wir verwenden den Wert 0, wenn die Zutat nicht verwendet wird.

Wenn man nur die Kuchen betrachtet,
dann ist eine Auswahl daraus ein Vektor `k` im *Kuchenvektorraum*.
Jedes `k_j` ist die Anzahl der Kuchensorte `j`.

Will man von einer Auswahl von Kuchen auf die Zutaten kommen,
dann ist das eine **Koordinatentransformation**.
Um die Gesamtmenge `z_i` zu erhalten muss man die Anzahl von jeder Kuchensorte `k_j`
mit der jeweiligen Zutatmenge multiplizieren.
Das läuft auf eine Matrixmultiplikation hinaus.

`z = ZK \cdot k = \sum_j ZK_{ij}k_j`

In `ZK` ist jede Spalte ein Rezept,
d.h. die Zutaten (**Komponenten**) für den Kuchen `j`.

Um auf den Preis `p` im *Preisvektorraum* zu kommen,
multiplizieren wir wieder

`p = PZ \cdot z = PZ_{1i} z_i`

`PZ` ist eine Matrix mit einer Zeile.
Die Anzahl von Zeilen ist die Dimension des Zielvektorraumes.

<file_sep>/chcko/r/cq/en.rst
.. raw:: html

    %path = "maths/operations"
    %kind = chindnum["texts"]
    %level = 9
    <!-- html -->

A very basic operation is the **addition**.
Addition can be seen as cardinality of the union of two disjoint sets.

    `|M\cup N|=|M|+|N|` if `M\cap N = \emptyset`

This abstract view can be applied to concrete cases, if we identify the unit of
a resource (length, mass, ...) with an element and there is no overlapping,
because the resource can be dispatched only once.

In the application one must take the physical system into account though.
For example elastic rods inserted vertically into a tube might not add their
lengths due to their elasticity and weights.
Volumes of liquids when mixed might not add, because the molecules can
use the space more efficiently in the mixture.

**Multiplication** one first encounters when calculating the area of a rectangle.
One either can add all unit squares (Addition) or
one repeats (multiplication) the rows or the columns (commutativity of `\cdot`)
If we address every unit square with coordinates `(i,j)`, then multiplication
counts all combinations of `0 <= i <= a` and `0 <= j <= b`, which yields `a\cdot b`.

In a square of side length `a` one has `a\cdot a` unit squares, in a cube of
side length `a` one has `a^3` unit cubes ...  Here we count combinations of a
set `M` `n` times with itself.  `|M\times \dots \times M| = |M|^n`.  Thus we
have come to the **power** operation.

- Multiplication is a shorthand for addition.
  So multiplication is a second level operation.

- Power is a shorthand for multiplication.
  Power therefore is a third level operation.

**Operation** is another name for **function** (:lnk:`r.cr`), if certain rules
like **assoziative law** or **commutative law** apply.  An **operation** can
easily be made to a new set by combining it with a value {(value,operation)}.
(see Zahlen: :lnk:`r.ci` and `lambda calculus <http://en.wikipedia.org/wiki/Lambda_calculus>`_).
These are then sets of instructions or **operators**, which can be applied to
other values of other variables, e.g. 3m = (3,times) m, i.e. 3 = (3,times).

<file_sep>/chcko/r/ce/de.rst
.. raw:: html

    %path = "Mathe/Funktionen/Log"
    %kind = chindnum["Texte"]
    %level = 10
    <!-- html -->

Logarithmus
-----------

Will man vom Ergebnis des Potenzierens wieder zurück zu den Ausgangszahlen,
dann gibt es zwei Wege, nämlich zur Basis und zur Hochzahl.

Zur Basis kommt man durch Potenzieren mit dem Kehrwert, also `(3^2)^{\frac{1}{2}} = 3`,
auch Wurzelziehen genannt.

Zur Hochzahl kommt man durch den **Logarithmus**, also `\log_{3}(3^2)=2`.

Aus dem Rechnen mit Potenzen zu gleicher Basis,
z.B. `2^32^2=2^{3+2}`
und `\frac{2^3}{2^2}=2^{3-2}` ergibt sich, dass der Logarithmus aus
*mal* *plus* und aus *teilen* *minus* macht.
Aus Wiederholen von Multiplikation (Potenzieren)
wird dadurch Wiederholen von Addition (Multiplikation):

.. math::

    \begin{matrix}
    \log ab &= \log a + \log b \\
    \log \frac{a}{b} &= \log a - \log b \\
    \log b^c &= c\log b
    \end{matrix}


Aus der letzten Regel ergibt sich, dass man den Logarithmus zu einer beliebigen
Basis wie folgt berechnen kann:

.. math::

    b^x &= d \\
    x &= \frac{\log d}{\log b}


Exponentialgleichungen, also Gleichungen, wo man den Exponent (die Hochzahl) sucht,
löst man am besten, indem man zuerst so lange umformt, bis man `b^x = d` hat,
dann wendet man auf beiden Seiten den Logarithmus an.

Der Logarithmus bezieht sich immer auf eine bestimmte Basis.
Wenn diese nicht angegeben ist, dann wird mit `\log` meistens die Basis 10 angenommen,
oft, etwa in Programmiersprachen, aber auch die Eulersche Zahl e=2.71828182846...

Es gilt:

.. math::

    \log_{10} 10 = \log 10 = \text{lg} 10 = 1\\
    \log_e e = \ln e = 1\\
    \log_2 2 = \text{lb} 2 = 1\\

<file_sep>/chcko/r/bd/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from math import log
from chcko.chcko.hlp import Struct


def chiven():
    g = Struct()
    g.Kn = randrange(1000, 2000)
    g.R = randrange(100, 200)
    g.i = randrange(2, 9)
    return g


def chalc(g):
    r = log(g.Kn * g.i / 100.0 / g.R + 1) / log(1.0 + g.i / 100.0)
    return [r]
<file_sep>/chcko/r/cd/de.rst
.. raw:: html

    %path = "Mathe/Finanz/Zinsen"
    %kind = chindnum["Texte"]
    %level = 10
    <!-- html -->


`K` Kapital

    Ein Geldbetrag.

`i` Zinssatz

    Die Zu- oder Abnahme von `K` wird in %=1/100 angegeben.

    - Zinswert: `3\% K = 0.03 K`.
    - Zunahme: `K + 3\% K = (1+3\%) K = 1.03 K`.
    - Abnahme: `K - 3\% K = (1-3\%) K = 0.97 K`.

`n` Perioden (Jahre/Quartale/Monate/Tage)

    Zum Zinsatz `i` gehört immer auch ein Zeitraum, in dem die Zunahme oder Abnahme stattfindet.

    - `i` meint ein Jahr (Jahreszinssatz, Effektivzinssatz)
    - `i_{12}` meint ein Monat
    - `i_4` meint ein Quartal

    Nach diesem Zeitraum ist K um den `iK` größer, also `K_{n=1} = K_0 (1+i) = K_0 q` (q = 1+i).

Zinseszinsen


    Am Anfang eingelegtes Kapital ist nach einer Periode
    (n=1) `K_{n=1} = K_0 (1+i) = K_0 q` wert, nach n=2 Perioden `K_0 q^2`, nach n=3 Perioden `K_0 q^3`...

    Nach n Perioden:

    - `K_n = K_0 q^n`

    - Aufzinsen: Ein Kapital wird mit `q^n` multipliziert, um den Wert `n` Perioden später zu erhalten.
    - Abzinsen: Ein Kapital wird mit `q^{-n}` multipliziert, um den Wert `n` Perioden früher zu erhalten.

Rente

    Eine Rente ist eine Zahlung (Rate `r`) in regelmäßigen Zeitabständen (Perioden).
    Die Periodenzahl für jede Rate ist anders.
    Die Endwerte aller Raten aufsummiert ergibt die Rentenformel:

    `R_n = \sum_{m=0}^{n-1} r_m = \sum_{m=0}^{n-1} r q^m = r \frac{q^n - 1}{q-1}`

    Diese Formel kann man anwenden, um den Endwert `R_n` der Rente zu berechnen,
    wenn die Rente am Ende jeder Periode gezahlt wurde (nachschüssig).

    - Nachschüssige Rente: `R_n = r \frac{q^n - 1}{q-1}`

    - Vorschüssige Rente: `R_n^v = q R_n`

    **Barwert** der Rente ergibt sich durch Abzinsen des **Endwertes** `B_n = R_n q^{-n}`.

Unterjährige Rente

    Um den unterjährigen Zinsatz mit dem Jahreszinssatz vergleichen zu können, muss man umrechnen.

    Lineare Umrechnung, wenn in den Monaten oder Quartalen keine Verzinsung stattfindet:

    - `i_{12} = i/12`
    - `i_4 = i/4`

    Konforme (äquivalente) Umrechnung bei unterjähriger Verzinsung:

    - `i = (i_{12} + 1)^{12} - 1`
    - `i = (i_4 + 1)^4 - 1`

    Wenn ein Jahreszinssatz gegeben ist und eine monatliche Rente zu berechnen ist,
    dann muss zuerst **auf den monatlichen Zinssatz umgerechnet** werden.

Rentenrest

    Um zu beantworten, wieviel Kapital zu einem Zeitpunkt
    während der Rentenlaufzeit noch übrig ist, zählt man den Rentenwert
    bis zu diesem Zeitpunkt vom Kapitalwert an diesem Zeitpunkt ab.

Umrechnung einer Rente in eine andere

    - Man ermittelt zuerst den Endwert der einen Rente `R_n`.
    - Dieses `R_n` muss man dann zum Endwert der anderen Rente auf- oder abzinsen.
    - Durch Verwendung der Rentenformel kann man dann die gesuchte Größe (`n`, `q`, `r`) der neuen Rente ausrechnen.

Kapitalvergleich, Angebotsvergleich

    Um Gelder vergleichen zu können muss man sie auf den gleichen Zeitpunkt (etwa jetzt, also Barwert)
    umrechnen. Umrechnen geht über Auf- oder Abzinsen oder unter Verwendung der Rentenformel.


<file_sep>/chcko/r/z/__init__.py
# -*- coding: utf-8 -*-
import random
from sympy import Poly, solve
from sympy.abc import x

from chcko.chcko.hlp import Struct, norm_int, norm_frac


def chiven():
    p = 0
    x1 = x2 = 0
    while p == 0 and x1 == x2:  # p could become 0
        x1, x2 = random.sample(list(range(2, 9)) + list(range(-9, -2)), 2)
        p = -(x1 + x2)
        q = x1 * x2
    a = random.sample(list(range(2, 6)) + list(range(-5, -1)), 1)[0]
    b = p * a
    c = q * a
    g = Struct(coef=[a, b, c])
    return g


def chalc(g):
    # g=chiven()
    p = Poly(g['coef'], x, domain='ZZ')
    x1, x2 = solve(p)
    xs = 1.0 * (x1 + x2) / 2
    ys = p(xs)
    answers = [
        norm_int(x1) +
        ', ' +
        norm_int(x2),
        norm_frac(xs) +
        ',' +
        norm_frac(ys)]
    return answers


def chorm(answers):
    #answers = chalc(chiven())
    a = answers[:]
    res = a[0]
    try:
        sa = sorted([norm_int(aa) for aa in a[0].split(',')])
        if len(sa) == 1:
            res = sa * 2
        else:
            res = sa
    except:
        pass
    a[0] = ','.join(res)
    a[1] = ','.join([norm_frac(aa) for aa in a[1].split(',')])
    return a
<file_sep>/chcko/r/cp/de.rst
.. raw:: html

    %path = "Mathe/Mathe+Information"
    %kind = chindnum["Texte"]
    %level = 9
    <!-- html -->

Computer und Mathematik
-----------------------

Wir Menschen verarbeiten Information und haben die Regeln dazu
abstrahiert und Gesetzmäßigkeiten entdeckt. Das Resultat ist
die Mathematik.

Der Computer verarbeitet auch Informationen und kann die
Ergebnisse der Mathematik anwenden. Er kann auch schon
genutzt werden, um neu Regeln zu entdecken,
oder um Wege, Beweise, zu bekannten Zusammenhängen zu finden.

Die Computerwissenshaft Informatik kann in der Hinsicht als Teilgebiet
der Mathematik angesehen werden, jetzt mit vielen Erweiterungen
welche speziell auf die Eigenheiten der Informationsverarbeitung
von Computern eingeht.

Weil der Mensch jetzt den Computer hat, werden nicht nur
Rechnungen sondern zunehmend formalisierte Denkprozesse dem Computer überlassen.
Auch Lernen, Abstrahieren und Synthetisieren (kreative Aufgaben)
kann der Computer übernehmen, wenn auch derzeit noch wenig.

Der Computer macht also nicht nur Rechnen unglaublich schneller,
sondern er hat das Potential alle Denkprozesse des Menschen zu übernehmen.

Die Mathematik beschäftigt sich mit Informationsverabeitung.
Aber was ist Information?

Information
-----------

Die Kommunikation zwischen zwei Menschen, bei der Information
ausgetauscht wird, kann auf einen elementaren Prozess reduziert werden:
den Auswahlprozess (Selektion, Entscheidung)

Es braucht eine

- Menge, aus der ausgewählt werden kann (Angebot, Auswahl, Selektion).
- Das Auswahlverfahren (Selektion, Entscheidung)

Die Auswahl (Selektion) ist ein wiederholter Vorgang.
Ein Element wird exklusiv ausgweählt (nur eins) und jedes Element kommt dran.
Die Summe aller Auswahlvorgänge ist eine **Abbildung**.

.. admonition:: Hinweis

    Die kleinste Anzahl aus der man noch auswählen kann ist 2.
    Dashalb ist da **bit** auch die kleinste Informationseinheit.

Der Sender wählt aus Konzepten in seinem Kopf aus, bildet diese auf Worte ab,
welche dann mittels Lauten oder Schriftzeichen kodiert und gesendet werden.

Der Empfänger macht den umgekehrten weg.

Laute, Schriftzeichen und Ziffern sind dazu da,
um eine Vielheit zu erzeugen  (Wörter, Zahlen),
auf die Konzepte abgebildet werden können.

.. admonition:: Hinweis

    Mit Zahlen kann man alles auswählen, was man mit Worten
    auswählen kann, etwa indem man die Elemente in eine Reihe bringt
    und dann mit der Zahl eine Position auswählt.
    Worte werden assiziativ verwendet, abar auch das geht mit Zahlen.

Eigentlich arbeiten alle dynamischen System auf diese Art.
Es gibt Mengen von möglichen Zuständen und Selektion. Beispiele:

- In der Biologie: Varianten durch Mutation und Selektion durch die natürliche
  Umgebung, die Artgenossen und das Biotop
- In der Wirtschaft: Angebot und Nachfrage
- In der Gesellschaft: Formen der Organisation und deren Zulauf
- In der Politik: Politiker und Wähler
- In der Wissenschaft: Theorien und deren Nützlichkeit zur Erklärung von Phänomenen
- Ideen und deren Befürworter
- Gedanken im eigenen Kopf und deren Bestätigung durch Erfahrungen
- ...

Seit der Quantenmechanik weiß man, dass der Zufall ein Prinzip der Natur ist,
dass nicht alles vorbestimmt ist, sondern dass die Auswahlprozesse wirklich
neue Kombinationen enstehen lassen, flüchtige und auch bleibende.

Die Natur verarbeitet Information, indem sie Zustände verteilt.  In diesem
Sinne ist das Universum vergleichbar mit einem Computer oder mit Tieren
einschließlich dem Menschen, oder besser, letztere beherbergen das gleiche
Prinzip.

Energie, Entropie
.................

:inline:`r.cv`
:inline:`r.a1`


Mathematik und Information
--------------------------

Als elementare Einheit der Information(sübertragung) haben wir

- Menge
- Auswahl

erkannt.

In welchem Bezug steht das zur Mathematik?

Mengen und Variablen
....................

Die Menge finden wir in der Mengenlehre als Fundament der Mathematik.

Um Elemente aus der Menge auszuwählen, kann man jedem Element ein bit zuordnen
und dann eine Auswahl mit 0 (nicht verwendet) und 1 (verwendet) codieren.
Mit weniger bits kommt man aus, wenn man herausfindet, welche Elemente
sich gegenseitig ausschließen.

Eine Menge, aus der nur ein Element ausgewählt werden kann,
ist eine Variable.
Das Element das ausgewählt wird heißt Wert.

.. admonition:: Variable

    Variablen bestehen aus Werten.

Gemeint sind aber nicht Zahlen sondern die realen Dinge.  Erst über eine
Abbildung wird den realen Werten einer realen Variablen durch Vergleich mit
Einheiten eine Zahl zugeordnet (Koordinate).

Die Mathematik beschreibt die Realität indem Variablen ausfindig gemacht werden
und Abhängigkeit zwischen ihnen aufgestellt werden.

Struktur
........

Ein wichtiger Aspekt der Informationsverarbeitung ist die Abstraktion.
Durch Vergleich werden Gemeinsamkeiten gefunden und diese dienen
dann zum Wiedererkennen. In der Programmierung gibt es eine wichtige Regel:
Don't Repeat Yourself (DRY). So macht es auch die Mathematik.
Muster die sich wiederholen, werden abstrakt beschrieben und konkrete
Objekte werden zu Beispielen dieser Strukturen (z.B. Gruppe, Ring, Körper,...).

Das macht den Informationsaustausch (Kommunikation) viel effektiver.  Statt
wiederholt zu beschreiben, wie man in `\mathbb{Z}` mit `+` umgeht und in einem
Vektorraum und in ..., sagt man `(\mathbb{Z},+)` und `(V,+)` sind Gruppen.

Die Mathematik als Wissenschaft baut eine Struktur auf,
jetzt im Sinne dass sukzessive neu Konzepte dazukommen,
eine Menge aufgebaut wird, aus der man auswählen kann.
Neue Arbeiten verwenden diese Konzepte (diese Sprache)
und erweitern sie.

.. admonition:: Struktur

    Auch die sukzessive Erweiterung einer Struktur
    ist ein Entwicklungsvorgang allgemeiner dynamischer System
    (biologische Evolution, Wirtschaft, ... sie Beispiele oben).

    Damit sich komplexere und länger währende Strukturen entwickeln können,
    müssen diese die Energieverteilung (in der Wirtschaft die Geldverteilung)
    mit aufbauen, so dass Subsysteme richtig dosiert versorgt werden.


Algorithmik
...........

Um einen Wert aus einer Variablen zu bestimmen (auszuwählen)
hat die Mathematik die **Funktion**. Das ist auch der Name in der
Informatik, auch wenn in einer etwas anderen Bedeutung. Andere Namen sind
Unterprogramm, Subroutine, Prozedur, ...

:inline:`r.cw`

Die Auswahl eines Wertes einer Variablen kann von mehreren anderen Variablen abhängen.
Entsprechend haben Funktionen oft mehrere Parameter.  Bei der Definition einer
Funktion heißen sie **formale Parameter**.  Eine erster Auswahlprozess passiert dann,
wenn diese formalen Parameters beim Aufruf (Anweisung) zu aktuellen Werten
anderer Variablen (**aktuelle Parameter**) abgebildet werden.

Funktionen in Programmiersprachen liefern nicht unbedingt den Wert einer
Variable zurück, sondern oft mehrerer und es können diese Wert auch irgendwo
abgespeichert werden, statt sie zurück zu liefen, was theoretisch aber das
gleiche ist. Es ist jedoch ein gutes Design, Variablen und deren Abhängigkeiten
zu benennen und damit von anderen zu trennen.

Funktionen bestehen aus Aufrufen anderer Funktionen.

- hintereinander ausgeführte Aufrufe heißen **Sequenz** (engl. sequence).
- Entscheidungen, welche Aufrufe unter welchen Bedingungen gemacht werden, heißen
  **Verzweigung** (engl. branch)
- wiederholte Ausführung heißt **Schleife** (engl. loop)

Diese Algorithmik ist in der Mathematik überall versteckt, in Zahlen, in Ausdrücken
und Symbolen (Polynome, `\sqrt{}`, `\lim`, `\int`, ...), in Sätzen und Beweisen.
Die ganze Mathematik kann man sich als großes Programm vorstellen,
aber leider das Meiste noch in einer Sprache, die der Computer nicht versteht.

.. admonition:: Darstellung

    Eine große Herausforderung ist die Darstellungen der Mathematik in eine
    Computersprache zu übertragen. Aber von letzteren gibt es auch viele,
    unter anderem solche die speziell für die Mathematik gemacht wurden.

    Viele unterschiedliche Darstellungen erhöhen den Aufwand
    und vermindern die Anwendbarkeit in einem unvorstellbarem Ausmaß.

    Das gleiche gilt auch für die vielen menschlichen Sprachen.


.. admonition:: Zahlen

    Bei der Einführung der Zahlen ist es naheliegend algorithmische Aspekte
    direkt mit der Anzahl zu verbinden:

    - Anzahl mit + und -: ganze Zahlen

    - Anzahl mit * und /: rationale Zahlen

    Dann ergeben sich folgende Betrachtungen:

    - Zahlen sind elementare Anweisungen (2 hinzu, mal 2, ...)

    - analytische Ausdrücke sind Programme/Funktionen

    - Termvereinfachung ist Programmvereinfachung, auch Profiling genannt


.. admonition:: Gleichung

    Die Gleichung ist eine Funktion, die das Ergebnis eines Vergleiches liefert.
    Äquivalenzumformungen von Gleichungen sind auch eine Art Profiling.

    Gleichungen und Ungleichungen dienen auch dazu, implizit Mengen zu beschreiben.


<file_sep>/chcko/r/co/en.rst
.. raw:: html

    %path = "maths/abstract-concrete"
    %kind = chindnum["texts"]
    %level = 9
    <!-- html -->


In mathematics as in daily life **concrete** observations
that repeat, are described once and then referred to later.
The common pattern in many observations is called **abstrakt**.
They make descriptions shorter in their totality.

For learners it is often difficult to link the abstract with the concrete
again. Therefore it is good to comment definitions and theorems with motivation,
examples and applications.

First one normally starts with the concrete, recognizes common patterns by comparing,
which is called **analysis**, and the result is the **abstraction**.
This is **reduction of redundancy** and **compression**, a fundamental cognitive process.

.. admonition:: Note

    Mathematics often uses the **equivalence relation**
    (= **reflexive, symmetrische und transitive Relation**, `\sim`)
    as a tool to describe abstraction.
    One focuses on one or a few properties and leaves others out.
    All elements with a certain value of the property variable
    are equivalent and form an equivalence class.
    All equivalence classes make up the **quotient space**
    `M/\sim`, which is a set of disjoint subsets of `M`.

Abstract concepts can be combined again (**Synthesis**).
This is the principle of **creativity**.

<file_sep>/chcko/r/b/en.rst
.. raw:: html

    %path = "maths/vectors"
    %kind = chindnum["texts"]
    %level = 11
    <!-- html -->

Vectors
-------

What is a Vector?
.................

    A **multidimensional vector** can be seen as independently choosing (value)
    from more variables.

    The values (number+unit) must be **addable** independently.

    The units are the **unit vectors**. Together they form the **basis**
    and are therefore also called **basis vectors**.

    The choice from one variable is a vector, too, a **one-dimensional** vector.

    The whole vector can be multiplied by a number, the **scalar**, and yields a vector again.

Example:

    - If I go into a shop, then the products there are my vector space
      (coordinate system, CS) and my shopping basket is a vector, i.e. a fixing
      of the value (how much?) of each variable (here product).
    - If my wife went shopping, too, then the baskets add up independently at home,
      i.e. milk + milk, butter + butter, ...

Coordinate Transformation
.........................

A matrix transforms a vector from one coordinate system to a vector of another
coordinate system.  Therefore we learn first about vectors. The matrix comes
into play, when we want to change from one coordinate system to another.

Example :inline:`r.a0`

How do we notate vectors?
..........................

- As column of numbers `\vec{x}=\begin{pmatrix}x_1\\x_2\end{pmatrix}`.
  The unit vectors, i.e. what the rows mean, one specifies separately.
- Written explicitly with units: `\vec{x}=x_1\vec{e_1}+x_2\vec{e_2}`
  (3 milk + 5 butter). If without arrow, then the superscript index
  normally mean the scalar (number) and the subscript index the unit
  (dimension, direction): `x=x^1e_1+x^2e_2`.

Notation is not the vector itself.

Vector Operations
-----------------

.. .. texfigure:: vector_dot_cross.tex
..       :align: center

.. tikz:: \coordinate (0) at (0,0);
    \coordinate (A) at (1,3);
    \coordinate (B) at (4,2);
    \coordinate (C) at (2,1);
    \tikzset{->}
    \draw[black,very thick] (0) -- (A) node [midway,left]{$\vec{x}$};
    \draw[black,very thick] (0) -- (B) node [near end,right,below]{$\vec{y}$};
    \draw[black,very thin]  (0) -- (C) node [midway,right,below]{$x_y$};
    \draw[-,thin] (A) -- (C) node [midway,right]{$x_{\perp y}$};


Apart from addition there are two other important vector operations.

- **dot-product (scalar product)**. It yields a number (scalar) that represents the dependence
  or with how little independence one can choose values.

  .. math:: \vec{x}\vec{y}=x_yy=y_xx=x_1y_1+x_2y_2

  - Orthogonal vectors result in 0 (no dependence).

  - For parallel vectors it is the product of the lengths.
    The length of a vector `\vec{x}` is thus `\sqrt{\vec{x}\vec{x}}`
    The length is denoted as `|\vec{x}|` or simply `x`.

  - `\vec{x_o}=\frac{\vec{x}}{x}` is the unit vector (length 1 in the direction of `\vec{x}`)

  - The dot-product defines an angle between two vectors: `\cos\alpha = \frac{\vec{x}\vec{y}}{xy}`


- **Vector product or cross product**. For a dimension `= 3` it produces
  a vector orthogonal to `\vec{x}` and `\vec{y}` and of length equal to the area
  of the parallelogram created by the two vectors.

  .. math::
        \vec{x}\times\vec{y}=x_{\perp y}y=y_{\perp x}x=
        \begin{vmatrix}
        \vec{e_1} & \vec{e_2} & \vec{e_3} \\
        x_1 & x_2 & x_3 \\
        y_1 & y_2 & y_3
        \end{vmatrix}

  If `\vec{x}` and `\vec{y}` are two-dimensional, then only the `\vec{e_3}` component of
  `\vec{x}\times\vec{y}` is different from 0. It is
  `\begin{vmatrix}
  x_1 & x_2 \\
  y_1 & y_2
  \end{vmatrix}=
  \begin{vmatrix}
  x_1 & y_1 \\
  x_2 & y_2
  \end{vmatrix}`.
  Compare this to: Determinant of 3 vectors in the 3D space are the volume of the parallelepiped
  created by the three vectors.


<file_sep>/chcko/r/cs/de.rst
.. raw:: html

    %path = "Mathe/Morphismen"
    %kind = chindnum["Texte"]
    %level = 10
    <!-- html -->

Der Begriff der Funktion aus der Mengenlehre, Elemente einer Menge
(Definitionsbereich) in eine andere Menge (Wertebereich) eindeutig abzubilden,
wird mit dem Begriff des Morphismus in der Kategorientheorie in der Hinsicht
abgeändert/verallgemeinert, dass man die ganze Abbildung ins Zentrum rückt und
Objekte unabhängig ob Quelle (domain) oder Ziel (codomain) zu einer Menge von Objekten O
zusammenfasst. Quelle und Ziel in der Menge der Objekte sind durch den
Morphismus bestimmt, bzw. Teil davon
(`D_f` ist Quelle von f, `C_f` ist Ziel von f, beide müssen nicht Mengen sein).
Mehrere Morphismen in der Menge der Morphismen M können sich ein Paar
(Quelle,Ziel) teilen.  (O,M,id) ist eine Kategorie. id ist der identische
Morphismus.

Ein wichtiger Aspekt bezüglich Morphismen ist, dass eine Struktur erhalten bleibt
(Ordnungsstruktur, Algebraische Struktur, topologische Struktur) und
je nach betrachteter Struktur gibt es Unterbegriffe (`f\circ g (D_g) = f(g(D_g))`):

- Monomorphismus: `f\circ g=f\circ h \implies g=h` (linkskürzbares `f`)
  oder `f` injektiv für Mengen als Objekte
  (`Beweis <http://www.proofwiki.org/wiki/Injection_iff_Monomorphism_in_Category_of_Sets>`_)

- Epimorphismus: `g\circ f=h \circ f \implies g=h` (rechtskürzbares `f`)
  oder `f` surjektiv für Mengen als Objekte
  (`Beweis <http://www.proofwiki.org/wiki/Surjection_iff_Epimorphism_in_Category_of_Sets>`_)

- Isomorphismus: `f` hat ein `g` für das `f\circ g=id_{D_g}` und `g \circ f = id_{D_f}`
  (Linksinverse = Rechtsinverse) oder `f` bijektiv für Mengen als Objekte

- Endomorphismus: `X\rightarrow X`

- Automorphismus: `X\rightarrow X` + Isomorphismus

- Homomorphismus (Algebra): `f(a+b)=f(a)+f(b)` (`+` möglicherweise unterschiedlich)

- Homöomorphismus (Topologie): `f` und `f^{-1}` stetig

- Diffeomorphismus (Differentialgeometrie): bijektiv, `f` und `f^{-1}` stetig differenzierbar



<file_sep>/chcko/r/ct/en.rst
.. raw:: html

    %path = "maths/direction"
    %kind = chindnum["texts"]
    %level = 11
    <!-- html -->

Variables one normally deals with, are extensive, i.e. quantities and not points.
3m means all points from 0 to 3m.

Two different variables, for which all combinations are possible can be called
orthogonal.  They generate the maximal set of combinations (area).
The *cross* product is maximal.

The addability is represented by the *dot* product. It is 0 for orthogonal quantities.

Quantities that show to the same direction can be added.
Different directions can be added component-wise.

- The **angle** results from the ratio of generated area and maximal area
  `\angle(\mathbf{v_1},\mathbf{v_2})=\arcsin\frac{|\mathbf{v_1}\times \mathbf{v_2}|}{|\mathbf{v_1}||\mathbf{v_2}|}`
  or from the ratio of the addable components to the whole length
  `\angle(\mathbf{v_1},\mathbf{v_2})=\arccos\frac{\mathbf{v_1}\mathbf{v_2}}{|\mathbf{v_1}||\mathbf{v_2}|}`

  The angle between orthogonal variables is `\frac{\pi}{2}`.

- and with complex numbers
  `\angle(z_1,z_2)=\arg(\frac{z_1\bar{z_2}}{|z_2||z_2|})=\arg{z_1\bar{z_2}}`.

Another word for angle is phase, that allows to overcome the meaning of direction by common use.
Essential is the comparison of two quantities regarding the addable components.
To this end variables that do not represent a direction, but have influence on addability,
can be mapped to the angle range `[0,2\pi]`, which then is called phase.

Examples:

- The time `t` of a vibration becomes `\varphi=\frac{2\pi}{T}t` or

- the combined time and space position of a wave becomes `\varphi=\frac{2\pi}{\lambda}x-\frac{2\pi}{T}t`.

`Re(Ae^{i\varphi})` then represents the currently addable amplitude.

<file_sep>/chcko/r/bc/en.html
%path = "maths/finance/annuity/annual->monthly"
%kind = chindnum["problems"]
%level = 11

<NAME> has \(K_0=\)€{{chiven.C0}} that she can cash in as a monthly annuity due.
She can choose either the runtime or the rate.
The annual interest is {{chiven.i}}% and shall be converted conformally
to a monthly interest.

<ol type="a">
<li>
How big is the monthly interest rate with {{chiven.n}} years runtime?
<br>Rate €
%chq(0)
</li><li>
How many months can <NAME> get a monthly amount of €{{chiven.r}} full
<br>Months
%chq(1)
</li><li>
and what is the remaining amount she gets the month after?
<br>Annuity rest €
%chq(2)
</li>
</ol>

<file_sep>/chcko/r/cw/en.rst
.. raw:: html

    %path = "maths/informatics/komplexity"
    %kind = chindnum["texts"]
    %level = 9
    <!-- html -->

Complexity

    To refer to a value of a variable one needs memory space.
    If the value (reference) can be calculated from (the values of) other variables,
    then one can do without that memory.
    This is why functions are important.

    On the other hand one has to do calculations, now,
    to reference to the value of the variable. This need time.

    **Complexity** is a meassure for the needed resources.
    If a lot of time is needed, then the time complexity is high.
    If a lot of memory is needed, the the space complexit is high.

    Since computing power varies widely one only mentions the order of
    magnitude in dependence of the cardinality of the data set to process via
    the O-notation , e.g. `O(n^2)`.

<file_sep>/chcko/r/ce/en.rst
.. raw:: html

    %path = "maths/functions/log"
    %kind = chindnum["texts"]
    %level = 10
    <!-- html -->

Logarithm
---------

The power operation generates a result from the basis and the exponent.
So from the result there are two ways back: either to the basis or to the exponent.

- To get the basis one forms the power of the result with the reciprocal of the exponent,
  e.g. `(3^2)^{\frac{1}{2}} = 3`. This is also called root.

- To get the exponent there is the **logarithm**, e.g. `\log_{3}(3^2)=2`.

From the calculation rules of exponents with same basis, e.g. `2^32^2=2^{3+2}`
and `\frac{2^3}{2^2}=2^{3-2}` follow the logarithm rules that make
*plus* out of *multiply* and *minus* out of *divide*.

The repetition of multiplication (power) becomes repetition of addition (multiplication).

.. math::

    \begin{matrix}
    \log ab &= \log a + \log b \\
    \log \frac{a}{b} &= \log a - \log b \\
    \log b^c &= c\log b
    \end{matrix}


From the last rule it follows how to calculate any logarithm with just one logarithm.

.. math::

    b^x &= d \\
    x &= \frac{\log d}{\log b}


An exponential equation, i.e. an equation that has the unknown in the exponent,
is solved best by first trying to bring it into the form `b^x = d` and then
apply the logarithm on both sides.

The logarithm always refers to a basis. If the basis is not specified,
then `\log` is either with Basis 10 or with basis e=2.71828182846... (Euler number)

It is

.. math::

    \log_{10} 10 = \log 10 = \text{lg} 10 = 1\\
    \log_e e = \ln e = 1\\
    \log_2 2 = \text{lb} 2 = 1\\

<file_sep>/chcko/r/cj/en.rst
.. raw:: html

    %path = "maths/numbers/combination with operations"
    %kind = chindnum["texts"]
    %level = 9
    <!-- html -->

If we combine with the counting number or natural numbers
a reversible process like adding and its counter process subtracting,
then we have introduced the **integers**.

.. math::

    \mathbb{Z} = \mathbb{N}\times\{+,-\}

Repeat the adding and we have a new operation: the multiplication.

Now let's combine this new operation with the integers.
The counter process is division.
Now we have introduced the **rational numbers**.

.. math::

    \mathbb{Q} = \mathbb{Z}\times\{+,-\}\\
    \mathbb{Q} = \mathbb{N}\times\{+,-\}\times\{\cdot,\div\}


Repeat the multiplication and we have the new operation "to the power".

Now not any more that analogously, but basically yes,
rationals combined with power operation extend to a new set of numbers
the **algebraic numbers**.

Numbers so far contain processes, so the make up an **algorithm**.  If we allow
infinite algorithms, we extend further by including the **irrational numbers**
(algebraic and transcendental) and thus extend to the **real numbers**.

.. admonition:: Note

    Finite and infinte algorithms: `\sqrt{2}` is infinite if expressed with the
    basic operations.  But if we do not evaluate `\sqrt{2}` but use it
    symbolically only then this is a finite algorithm.


<file_sep>/chcko/r/dk/de.rst
.. raw:: html

    %path = "Mathe/Funktionen/exponentiell"
    %kind = chindnum["Texte"]
    %level = 11
    <!-- html -->

.. role:: asis(raw)
    :format: html latex

Grundlegendes
-------------

In der **exponentiellen Funktion**

.. math::

    y = a^x

nennen wir

- `x` den **Exponenten**
- `a` die **Basis**
- `y` die **exponentielle Funktion** von `x` zur Basis `a`

Der **Exponent** sagt, wie oft die *Multiplikation* mit `a` wiederholt wird.
`a` muss eine positive reelle Zahl sein : `a\in\mathbb{R}`.

.. admonition:: Multiplikaton

    Multiplikation ist eine Operation der realen Welt, die als
    Zahl codiert wird. In der Zahlenmenge `\mathbb{Q}`
    ist die Operation Teil der Zahl: `2` meint `\cdot 2` und `1/2` meint `/2`.
    Das Zeichen `\cdot` steht für die Multiplikation und `/` steht für die umgekehrte (inverse)
    Operation, die Division, welche mit der Einbindung der Brüche in `\mathbb{Q}` Teil der Zahl wurde.
    Also sprechen wir nur mehr von Multiplikation und meinen die Anwendung
    der Operation aus `\mathbb{Q}\subset\mathbb{R}`.

Wenn `a` größer als `1` ist, dann wächst `y` mit `x` *strikt monoton*: `x_1<x_2 \Rightarrow y_1<y_2`.

.. tikz:: \begin{axis}[grid=both,axis lines=middle,xmin=-3,xmax=3,ymin=0,ymax=8, samples=50]
     \addplot[green]  {pow(2,x)} node[above]{$y=2^x$};
    \end{axis}

Wenn `a` kleiner als `1` ist, dann fällt `y` mit `x` *strikt monoton*: `x_1<x_2 \Rightarrow y_1>y_2`.

.. tikz:: \begin{axis}[grid=both,axis lines=middle,xmin=-3,xmax=3,ymin=0,ymax=8, samples=50]
     \addplot[green]  {pow(1/2,x)} node[above]{$y=(\frac{1}{2})^x$};
    \end{axis}


Diskussion
----------

Vergleichen wir die Anzahl der Wertekombinationen von `n` bits:

.. math::

    2^n

mit dem Wachstumsprozess, wie etwa das Anwachsen des Kapitals mit der jährlichen Verzinsung

.. math::

    (1+\frac{i}{100})^n

oder das besonders interessante natürliche Wachstum

.. math::

    e^x = \lim_{n->\infty}(1+\frac{1}{n})^{nx} =
    \lim_{m->\infty}(1+\frac{x}{m})^m = (1+\frac{x}{\infty})^\infty

`e` ist `Eulersche Zahl <https://de.wikipedia.org/wiki/Eulersche_Zahl>`_
deren Bedeutung auf dem gegebenen Zusammenhang beruht.

Der Schlüssel zum Vestehen der Gemeinsamkeiten steckt in der Interpretation
von **Information** als Wachstumsprozess.
Jedes Bit vergößert um `1` Mal die vorhandene Anzahl von Wertekombinationen.

Notieren wir diesen Aspekt des Bits mit `(1+1)`, um zu betonen, dass `1` dazu kommt.
Die Klammern machen den Ausdruck zu einem Operator, einem Element der Zahlenmenge `\mathbb Q`.
`n` wiederholte Anwendungen von `(1+1)` erzeugen eine Vielzahl der Größe

.. math::

    (1+1)^n = 2^n

Jedes Bit wird zur bestehenden Menge von Wertekombinationen "dazuverzinst".

Das Informationmaß einer realen Variablen der Größe `C` ist die Anzahl
`n=\log_2 C` Bits, die notwendig sind, damit wir auf `C` Kombinationen kommen.

.. admonition:: Vergleich mit welcher anderen Variable?

   Statt Bits könnten wir ebensogut die betrachtete Variable selbst nehmen,
   weil diese ist physikalisch present. Kombinationen sind aber auch
   physikalisch und auch die Auswahl von Werten, welche letztendlich Veriablen
   erzeugt, ist ein physicalischer Prozess.  Die Anzahl der beteiligten
   Variablen spielt dabei eine Rolle. Das bedeutet erstens, dass Information
   physikalisch ist und zweitens, in Hinsicht auf die Quantenmechanik, dass die
   Anzahl der beteiligten Variablen immens groß ist und die individuellen
   Beiträge minimal sind.

Wenn wir von der *Anzahl an Variablen* starten, dann gibt uns die
*Exponentialfunktion* die *Anzahl and Wertekombinationen*. Wenn wir von der
*Anzahl der Werte* starten, dann gibt uns der *Logarithmus* die *Anzahl der
Variablen*, die zur Wertegenerierung notwendig ist.

Bei der **Zinsrechnung** schauen wir auf die Geldmenge (die `1`),
welche auf der Bank `i` Prozent zinsen abgibt.
In `n` Jahren wächst die `1` zu

.. math::

    (1+i/100)^n = q^n

Der *Wachstumsfaktor* `q` ist nicht `2`, sondern normalerweise nur etwas über `1`. Das
"Informationsmaß" in diesem finanziellen Kontext würde die Anzahl
der Jahre sein.

Der essentielle Unterschied bezüglich den Bits
ist, dass, was hinzugefügt wird, ein *Bruchteil* von dem ist, was da ist.
Aber ob Bruchteil oder nicht ist nur ein Frage der Einheit.

Die Einheiten von Lebewesen sind Zellen und die ultimativen Einheiten der
realen Welt sind Quanten.  Beide sind sehr klein im Vergleich zu den Dingen
unserer täglichen Wahrnehmung.  Mit solchen kleinen Einheiten können wir auch
beliebig oft (= unendlich oft) "verzinsen":

.. math::

    \lim_{m->\infty}(1+\frac{x}{m})^m = \lim_{n->\infty}(1+\frac{1}{n})^{nx} = e^x

In der ersteren Gleichung können wir sehen, dass wir mit dem Verändern der
*Verzinsungsschritte* auch die *Wachstumsfaktor* verändern. Wegen der
Bedeutung von `e^x` wird der Wachstumsfactor `q` in `y=q^n` oft zum Exponenten von `e`
verlegt (`y=e^{kx}`).  `k = \ln q` heißt dann *Wachstumskonstante*.

.. admonition:: Natürliche Verzinsung in der Finanzwelt

  Auch in der finanziellen Welt sind die tatsächlichen
  Verzinsungsschritte sehr klein. Aber die Bank gibt sie ihren Kunden in
  größeren Zeiteinheiten weiter.

`x` ist die Information in der **natürlichen Informationseinheit**
`nat <https://de.wikipedia.org/wiki/Nit_(Informationseinheit)>`_.
Im Pinzip teilen wir dabei eine Variable in unendliche viele undendlich kleine Variablen auf,
so dass der Wachstumsfaktor pro Schritt beinahe bei `1` liegt.

<file_sep>/chcko/r/j/__init__.py
# -*- coding: utf-8 -*-

import random
from sympy.abc import x
from sympy import exp, sin, cos, latex, Rational, S, N, integrate, sstr
from chcko.chcko.hlp import Struct

__all__ = ['chiven', 'chalc', 'low', 'high']

rs = []
for i in [2, 3, 5]:
    for j in [2, 3, 5]:
        if i == j:
            continue
        rs.append(x ** Rational(i, j))
sp = [sin(x), cos(x), exp(x), 1 / x]

funs1 = rs[:]  # 1
for i in [2, 3, 5]:
    for j in [2, 3, 5]:
        if i == j:
            continue
        funs1 = funs1 + [Rational(i, j) * fun for fun in rs]

funs2 = sp[:]  # 1
for i in [2, 3, 5]:
    for j in [2, 3, 5]:
        if i == j:
            continue
        funs2 = funs2 + [Rational(i, j) * fun for fun in sp]

crange = range(3, 10)
low, high = 0.5, 1
""" #Any of funs1 - any of crange has no intersection with any of funs2 within low and high:
    #f2 > f1
from scipy.optimize import brentq
E=lambda f: lambda v: f.subs(x,v).evalf()
cnt = 0
for f1 in funs1:
    for f2 in funs2:
        for c in crange:
            try:
                res=N(integrate(f2-(f1-c),(x,low,high)))
                if res < 0.1:
                    print(res)
                brentq(E(f2-(f1-c)),low,high)
                cnt = cnt + 1 #found a root
            except ValueError:
                continue
print(cnt) #=> 0 => no root
"""


def chiven():
    ff1 = random.sample(funs1, 1)[0]
    f1 = ff1 - random.sample(crange, 1)[0]
    f2 = random.sample(funs2, 1)[0]
    g = Struct(f1=sstr(f1), f2=sstr(f2))
    return g


def chalc(g):
    res = N(integrate(S(g.f2) - S(g.f1), (x, low, high)))
    return [res]
<file_sep>/chcko/r/y/__init__.py
# -*- coding: utf-8 -*-
import random
from sympy.abc import a, b, c, d, e, f, g, h, i, j, k, m, n, p, q, r, s, t, u, v, w, x, y, z
from sympy import sstr, simplify

from chcko.chcko.hlp import Struct, equal_0 as chequal

syms = [a, b, c, d, e, f, g, h, i, j, k, m, n, p, q, r, s, t, u, v, w, x, y, z]
syml = 'abcdefghijkmnpqrstuvwxyz'


def chiven():
    bn = random.sample(syml, 3)
    bd = bn[:]
    random.shuffle(bd)
    en = random.sample(range(-9, 9), 3)
    ed = random.sample(range(-9, 9), 3)
    nm = ''
    for i, ae in enumerate(en):
        nm = nm + '*{0}**{1}'.format(bn[i], ae)
    nm = nm.strip('*')
    dm = ''
    for i, ae in enumerate(ed):
        dm = dm + '*{0}**{1}'.format(bd[i], ae)
    dm = dm.strip('*')
    g = Struct(nm=nm, dm=dm)
    return g


def chalc(g):
    return [sstr(simplify(g.nm + '/(' + g.dm + ')'))]

chorm = lambda x: x
<file_sep>/chcko/r/c/__init__.py
# -*- coding: utf-8 -*-
import random
from math import log

from chcko.chcko.hlp import Struct


def chiven():
    g = Struct()
    g.r = random.sample(range(100, 200), 1)[0]
    g.n = random.sample(range(5, 10), 1)[0]
    g.i = random.sample(range(2, 14), 1)[0] / 10.0
    g.m = random.sample(range(2, 7), 1)[0]
    g.m = g.m * 10
    return g


def chalc(g):
    q = 1.0 + 1.0 * g.i / 100
    kn = g.r * (1 - q ** g.n) / (1 - q)
    kv = q * kn
    nm = log(g.m * (q - 1) + 1) / log(q)
    ieff = 100 * ((1 + g.i / 100.0) ** 12.0 - 1)
    return [kn, kv, nm, ieff]
<file_sep>/chcko/r/a1/de.rst
.. raw:: html

    %path = "Physik/S=E*t"
    %kind = 1
    %level = 12
    <!-- html -->

Ein System kann als Variable gesehen werden.
Der Zustand eines Systems ist ein Wert der Variable.

**Entropie** ist die Information einer Variable.
Entropie ist die *Anzahl der Werte einer Variable*.

Was mit Zustand gemeint ist, spielt keine Rolle,
d.h. wurde weg abstrahiert.
Nur die Anzahl spielt hier eine Rolle.

Die Zustände müssen vorkommen.
Das heißt, das System muss sich ändern.
**Energie** ist die **Anzahl der Zustände pro Zeit**.

.. math::

        S = Et

Man kann das auch anders herum betrachten:
Energie erzeugt die Zeit durch das Ändern der Werte.
Wenn das System aus vielen unabhängigen Variablen besteht,
wird so eine System-Zeitauflösung erzeugt,
welche in keiner unabhängigen Variablen vorkommt.

Eine konstante Menge an Energie kann

- wenige Zustände schnell wiederholen:  `\Delta S` und `\Delta t` klein
- viele Zustände langsam wiederholen: `\Delta S` und `\Delta t` groß

Ein System besteht oft aus Schichten.

In einem idealen Gas,
ist die Energie `Q=TS` gegeben durch

- die Temperatur `T`: durchschnittliche kinetische Energie eines Teilchens
- die Entropie `S`

Dies teilt das System in zwei Schichten:

- `T` meint die Informationsereignisse (Energie) einer Schicht unterhalb.
- `S` ist die Anzahl in der betrachteten Schicht.

Der Logarithmus in der Entropie kommt davon,
dass Information auf mehrere gleichartige Variablen verteilt wird (etwa Bit).
In der anderen Richtung folgt daraus der Exponent `e^S`.

Die Richtung der Teilchenbewegung unterteilt die Anzahl `N` der Teilchen

- nach Richtung: Faktor `1/2`, da exklusiv
- nach Ausrichtung: Faktor `3`,
  da `T` durchschnittlich gleichzeitig in allen 3 Ausrichtungen wirkt

Deshalb:

.. math::

    Q = ST = 3/2NkT = 3/2RT = 3/2pV

Für eine ideales Gas ist die Innere Energie gleich der Arbeit,
die an der Umgebung verrichtet wurde: `3/2 pV`.

Die mittlere Energie eines Teilchens `E` ist:

.. math::

    E = 1/2 m v^2 = 3/2 kT

Die Boltzmannkonstante `k` konvertiert zwischen Einheiten der Energie.
`v^2` kann besser mit Ereignissen in Beziehung gebracht werden als `T`,
aber auch `E` ist nur die Energie in der Schicht und nicht die ultimative
Einheit des elementaren Informationsereignisses pro Zeit.

Das elementare Ereignis ist durch das Plancksches Wirkungsquantum gegeben.
Die Summe dieser Ereignisse erzeigen Raum und Zeit: E-t, x-v, ...

<file_sep>/chcko/r/s/__init__.py
# -*- coding: utf-8 -*-

import numpy as np
import random

from chcko.chcko.hlp import Struct


def chiven():
    p1, p2 = random.sample(range(20, 30), 2)
    p0 = random.sample(range(140, 150), 1)[0]
    pp0 = random.sample(range(51, 60), 1)[0]
    A = np.array([np.array([p0, p1, p2]) / 10.0,
                  np.array([-pp0 / 100.0, 1, 1]),
                  np.array([1, 1, 1])])
    x0 = 100. / (100. + pp0)
    pp12 = pp0 / (100. + pp0)
    x1 = random.sample(range(1, int(100. * pp12)), 1)[0] / 100.0
    x2 = pp12 - x1
    x = np.array([x0, x1, x2])
    b = np.dot(A, x)
    g = Struct(A=A.tolist(), b=b.tolist())
    return g


def chalc(g):
    iA = np.linalg.inv(np.array(g.A))
    x = np.dot(iA, np.array(g.b))
    return [i for i in (100 * x).round().tolist()]
<file_sep>/chcko/r/bl/__init__.py
from random import randrange, sample
from chcko.chcko.hlp import Struct

def chiven():
    i1 = randrange(15, 90) / 10.0
    di = (randrange(1, 10) - 5) / 50.0
    if di == 0:
        di = 0.05
    i2 = i1 + di
    i_c = [4, 12, 1]
    i = [ii for ii in sample(i_c, 2)]
    i_n = ['\(i_{%s}\)'%str(ii) for ii in i]
    clc = lambda ai, ii: '{:.2f}'.format(
        100 * ((ai / 100.0 + 1.0) ** (1.0 / ii) - 1))
    i_v = [clc(i1, i[0]), clc(i2, i[1])]
    g = Struct(
        i1=i[0],
        i2=i[1],
        i1n=i_n[0],
        i2n=i_n[1],
        i1v=i_v[0],
        i2v=i_v[1])
    return g

def chalc(g):
    res = 2 if (
        (1 +
         float(
             g.i1v) /
            100.0) ** g.i1 -
        1 < (
            1 +
            float(
                g.i2v) /
            100.0) ** g.i2 -
        1) else 1
    return [res]

<file_sep>/chcko/r/ci/en.rst
.. raw:: html

    %path = "maths/numbers/NZQR long"
    %kind = chindnum["texts"]
    %level = 9
    <!-- html -->

.. contents::

This is not a first introduction to number,
but a discussion and interpretation with links to further resources
and an emphasis on algorithmic aspects (:lnk:`r.cp`).

Natural Numbers (`\mathbb{N}`)
------------------------------

The natural numbers are the real numbers in the sense that they represent a
count. All other sets of numbers have additional information or are quite
different altogether

The **count** is a real variable, which specifies the **cardinality** of a set.
A value of this variable, like three, means three things.
Further properties are not considered, they are abstracted away.
That is why every natural number can be seen as **equivalence class** (:lnk:`r.co`).

.. admonition:: Note

    In mathematics one makes a further distinction: **cardinal numbers** as above
    and **ordinal numbers** to specify the order.

The intuitive idea of `\mathbb{N}` is formalized with the
`Peano Axioms <http://de.wikipedia.org/wiki/Peano-Axiome>`_.

.. admonition:: Note

    Essentially `\mathbb{N}` is a construction
    of an ordered multitude (0 with successors),
    to address values of other variables (like count),
    just like words address concepts.

Zero
....

Zero was a great invention for the number representation, which the roman
system did not yet have. In general one can now include variables, even if they
are not there every time. This often helps to generalize description. As an
example in 103 the position coded tens variable is there, even if there is no
ten grouping in the number (:lnk:`r.cn`). Another example are vectors
(:lnk:`r.cg`).

The Integers `\mathbb{Z}` and the Addition
------------------------------------------

`\mathbb{Z}` is more than the count.

As motivation for the integers one can add to every element of `\mathbb{N}`
a process or a direction. 2 is then not only the count 2,
but has the additional information to add the 2 things (`2 = {2,+} = +2`).

If you understand `\mathbb{N}` already associated with a process
or direction, then it is a good idea to extend this to include
the same values but the undoing process or counter direction
to get back to the original situation. This way one intuitively comes
to the integers `\mathbb{Z}`.

`+` means to add and `-` means to subtract, but that can change.
The `+` is often dropped, but it must be implicitly assumed,
because an integer is not the same thing as a natural number.
It has additionally the reversible process or direction.

If you understand only count with `\mathbb{N}`,
then `\mathbb{Z}=\mathbb{N}\times\{+,-\}`.
Then `\mathbb{N}` is not a subset of `\mathbb{Z}`, but an
`isomorph <http://en.wikipedia.org/wiki/Homomorphism>`_
`embedding <http://en.wikipedia.org/wiki/Embedding>`_.

.. admonition:: Note

    An formal introduction of `\mathbb{Z}`, starting from `\mathbb{N}` with as few new concepts
    as possible (no `+` und `-`), is via **equivalence classes** (:lnk:`r.co`)
    of number pairs `(n,m)` from `\mathbb{N}` with the equivalence relation:
    `(n_1,m_1)\sim(n_2,m_2)\equiv n_1+m_2=n_2+m_1`.
    In the canonical representation one number is 0. `+2 = (2,0)` und `-2 = (0,2)`.

With `+` and `-` as opposite processes one has encoded this process in the number.
The `Addition` itself is then algorithmically a sequential execution or **sequence**:
`+2+(-2)` means: add 2 then(=+) subtract 2.
If you swap the numbers `((-2)+(+2))` you get the same result (**commutative law**).
With more numbers you can choose freely which to calculate first
`(-2)+((+2)+(+3))=((-2)+(+2))+(+3)` (**associative law**).

.. admonition:: Note

    The subtraction 2-2 is an abbreviation for +2+(-2).

The result of +2+(-2)= 0, the **neutral element** of addition.
+2 is the **opposite number (additive inverse)** of -2 and vice versa.
`(\mathbb{Z},+)` is an **abelean Group** (:lnk:`r.cl`).

.. admonition:: Note

    `+` as part of the number and `+` as binary operation are not the same.
    Similarly for `-`. `-` in addition can be a unary operation that returns the
    opposite number (additive inverse).

The Integers `\mathbb{Z}` and Multiplication
--------------------------------------------

A process can be repeated and multiplication says how often
addition (+2) or subtraction (-2) is repeated.  Algorithmically multiplication
is a loop:

    `3\cdot(-2) = (-2)+(-2)+(-2)`

Multiplication with 1 means the thing itself.
1 is the **neutral element** of the multiplication.

The multiplication with -1 means: revert the process,
i.e. make plus (+) to minus (-).

    `(-1)\cdot(-2) = +2`

    `(-1)\cdot(-1)\cdot(-2) = -2`

With this one can multiply every integer with every other integer and one gets
an integer again.`(\mathbb{Z},\cdot)` is **closed** and the **assoziative law**
holds.  This makes `(\mathbb{Z},+,\cdot)` to an **integrity ring**
(:lnk:`r.cm`).  `(\mathbb{N},+,\cdot)` alone is only a **semiring**
(:lnk:`r.cm`) .


Multiplication und die Rationalen Numbers (`\mathbb{Q}`)
--------------------------------------------------------

Analogous to `\mathbb{Z}=\mathbb{N}\times\{+,-\}` one can
think the repeating process united with the number and it is a good
idea to include the inverse process (dividing).

Which subtraction do I need to repeat 3 times in order to get a (-6) subtraction?

    (-6)/3 = -2

Analogous to `\mathbb{Z}=\mathbb{N}\times\{+,-\}` one can unite
`\mathbb{N}\times\{\cdot,\div\}` with the count multiplication and division.

The binary operations `\cdot` and `+` must be handled separately,
only the **distributive law** ties them together.

    `a\cdot(b+c) = a\cdot b + a\cdot c`

    e.g. `2\cdot(3+4)=2\cdot 3+2\cdot 4=14`

If you look for the part that repeated (multiplied)
yields no change, i.e. 1, then we get to the **reciprocal**,
which is the **inverse element of multiplication**.

While with (-6)/3 we still get a whole number, i.e. a multiple of 1,
this is not the case for the reciprocal in general.

Therefore the set is extended by these reciprocals to make it closed.
This is analogous to the extension from `\mathbb{N}` to `\mathbb{Z}`.

- There the process "add" was united to form a tuple (count,add).
  "add" has a reverse process "away".
  One has extended by (count, away).

- With `\mathbb{Q}` one extends (count,repeat) with the *reciprocal* (count,divide).

.. admonition:: Note

    In analogy to `\mathbb{N}\times\{+,-\}`
    one could write `\mathbb{Q}`-elements as:

    - `\cdot 2` corresponds to +2
    - `\div 2` corresponds to -2

    The binary operation `\cdot` then is only a successive processing and can be dropped.

    `(\cdot 2)\cdot(\div 2) = \cdot 2\div 2 = 1`

    But actually we write

    - `2\cdot 2^{-1} = 1` or
    - `2\cdot \frac{1}{2} = 1`

    the first is because one can add the exponent for the same basis
    and so we have `2\cdot 2^{-1}=2^1\cdot 2^{-1}=2^{1-1}=2⁰=1`.


`(\mathbb{Q},\cdot)` is a **abelean Group** with neutral element 1.

Because the multiplication in `(\mathbb{Q},\cdot)` shall yield an element of
`(\mathbb{Q},\cdot)` again (closure), one takes all fractions
`p/q=pq^{-1}` into `(\mathbb{Q},\cdot)`.
3/2 means to first do `\cdot 3` and then `\div 2` (reciprocal of 2).

    `\frac{3}{2}=3\cdot 2^{-1}=3\frac{1}{2}=\frac{1}{2}\cdot 3=2^{-1}\cdot 3`

`pq^{-1}` means to copy/repeat p times then divided q times.
To additionally multiply r times and undo that by dividing r times,
one doesn't change a thing.

    `pq^{-1}=rr^{-1}pq^{-1}=rp(rq)^{-1}=\frac{rp}{rq}`

All such pairs of numbers are equivalent and the canonical representation is
with p and q without common divisor.

.. admonition:: Hinweis

    `\mathbb{Q}` formally is introduced as set of equivalence classes
    of such equivalent number pairs:
    `(n_1,n_2)\sim(n_2,m_2)\equiv n_1m_2=n_2m_1`.


`\mathbb{R}` as extension with the irrational numbers `\mathbb{I}`
------------------------------------------------------------------

Count (`\mathbb{N}`) with addition (+) and subtraction (-) is `\mathbb{Z}`.
`\mathbb{Z}` with repetition (`\cdot`) and division (`\div`) is `\mathbb{Q}`.
If we stay with `+,-,\cdot,\div`, then we can do with `\mathbb{Q}`.

But if we want the power operation to be reversible, then we must extend again.
There is for example no `p/q` in `\mathbb{Q}`, for which `p^2/q^2=2`.
(Proof: p/q shall have no common divisor. If `p^2` is even, so is p (p=2n).
`p^2=4n^2=2q^2` means that q is even, but that is a contradiction).

There are though **algorithms** that make rationale Numbers (**sequences**),
whose square gets arbitrarily close to 2. All such algorithms are
combined into a equivalence class and this is then the new number `\sqrt{2}`

The irrational numbers `\mathbb{I}` are equivalence classes of number
sequences.  By naming the algorithm, and `\sqrt{}` refers to such an algorithm,
the irrational number is determined. One cannot write an irrational number as
decimal number. One can also not run the algorithm to an end, because it
does not terminate. So the irrational number is really the algorithm itself.

The irrational numbers get further classified as **algebraische** irrationals,
which are those that are roots of polynomials, and the **transcendental**
irrationals.  The latter exist, because there are functions beyond finite
polynomials, like Sin, Cos, ... most of which can be expressed with infinite
polynomials (series), though. `\pi` and `e` are transcendental.

New operations/functions lead to new numbers. But the definition
**equivalence classes of sequences** is so general that it
includes algebraic and transcendental numbers and `\mathbb{Q}` itself.

This is `\mathbb{R}`:

    `\mathbb{R} = \mathbb{Q} \cup \mathbb{I}`

Another very useful and exciting extension are the complex numbers `\mathbb{C}`(:lnk:`r.di`).

.. admonition:: Note

    Since `\mathbb{R}` includes all never ending number sequences, one could
    include `\infty` and `-\infty`, which are also never ending sequences of
    numbers, if it weren't for `\infty+1=\infty` and the like.
    Still in complex analysis (function theory) the complex number set is
    extended with `\infty` fruitfully.



<file_sep>/chcko/r/cl/en.rst
.. raw:: html

    %path = "maths/stuctures/group"
    %kind = chindnum["texts"]
    %level = 10
    <!-- html -->

*Group-like algebraic structures* consist of a set `M`
with a binary operation `\circ`, i.e. `(M,\circ)`.
For all elements (`\forall_{a,b\in M}`):

- `a\circ b \in M` **Closedness** `\rightarrow` **Magma**

- `a\circ(b\circ c) = (a\circ b)\circ c` **Associative Law** `\rightarrow` **Semigroup**

  - `a^n = a` **Idempotent** Semigroup `\rightarrow` **Lattice**

- `\exists_e|e\circ a = a\circ e = a` **Neutral Element** `\rightarrow` **Monoid**

- `\exists_\bar{a}|\bar{a}\circ a = a\circ\bar{a} = e` **Inverse Element** `\rightarrow` **Group**

- `a\circ b = b\circ a` **Commutative Law** `\rightarrow` commutative or **abelian Group**



<file_sep>/chcko/r/ci/de.rst
.. raw:: html

    %path = "Mathe/Zahlen/NZQR lang"
    %kind = chindnum["Texte"]
    %level = 9
    <!-- html -->

.. contents::

Das folgende ist keine erste Einführung, sondern
eine Art Diskussion zur Interpretation von Zahlen mit weiterführenden Links
und mit Augenmerk auf Algorithmik (:lnk:`r.cp`).

Natürliche Zahlen (`\mathbb{N}`)
--------------------------------

Die natürlichen Zahlen sind die eigentlichen Zahlen im Sinne,
dass sie eine Anzahl darstellen.
Alle anderen Zahlenmengen meinen mehr als nur die Anzahl.

Eine **Anzahl** ist eine reale Variable, welche die Mächtigkeit (**Kardinalität**)
einer anderen Menge angibt. Ein Wert dieser Variable, etwa drei, meint drei
Dinge.  Weitere Eigenschaften werden nicht betrachtet, werden weg-abstrahiert.
Deshalb kann jede natürliche Zahl als **Äquivalenzklasse** (:lnk:`r.co`)
angesehen werden.

.. admonition:: Hinweis

    Die Mathematik unterscheidet noch genauer: **Kardinalzahlen** wie eben
    und **Ordinalzahlen** zum Bezeichnen einer Ordnung.

Die intuitive Vorstellung von `\mathbb{N}` wird mit den
`Peano Axiomen <http://de.wikipedia.org/wiki/Peano-Axiome>`_
formalisiert.

.. admonition:: Hinweis

    Im Essentiellen ist `\mathbb{N}` eine Konstruktion
    einer geordneten Vielheit (0 mit Nachfolgern),
    um damit Werte anderer Variablen (etwa eben Anzahl)
    zu addressieren oder darzustellen, nach Art wie Wörter Konzepte darstellen.

Null
....

Die Null war eine großartige Erfindung zur Darstellung der Zahlen, die im
römischen Zahlensystem noch nicht da war. Allgemeiner kann man dadurch
Variablen einbeziehen, auch wenn sie nicht immer vorkommen. Das ermöglicht oft
eine allgemeinere Beschreibung. Zum Beispiel ist in 103 der positionscodierte
Zehner da, obwohl keine Zehnergruppierung da ist (:lnk:`r.cn`).
Ein anderes Beispiel sind Vektoren. (:lnk:`r.cg`).

Die ganzen Zahlen `\mathbb{Z}` und die Addition
-----------------------------------------------

`\mathbb{Z}` ist mehr als nur Anzahl.

Als Motivation für die ganzen Zahlen kann man bei `\mathbb{N}`
mit der Anzahl einen Vorgang oder eine Richtung verbunden denken.
2 ist dann nicht nur die Anzahl 2 sondern Anzahl `+` Hinzufügen
(`2 = {2,+} = +2`).

Wenn man sich `\mathbb{N}` als Anzahl kombiniert mit Vorgang
oder Richtung vorstellt, dann braucht man den Umkehrvorgang oder die Gegenrichtung,
um wieder zur Ausgangssituation zurückzukommen.
Man ist damit intuitiv bei den ganzen Zahlen `\mathbb{Z}` gelandert.

`+` meint dazugeben, `-` meint wegnehmen. Die Richtung ist aber Definitionssache.
Das `+` wird oft weggelassen, aber man sollte es hinzudenken,
da eine ganze Zahl eben nicht nur eine Anzahl ist,
sondern Anzahl und Vorgang/Richtung zusammen.

Wenn man sich unter `\mathbb{N}` nur Anzahl vorstellt, dann ist
`\mathbb{Z}=\mathbb{N}\times\{+,-\}`. Dann ist `\mathbb{N}` keine Teilmenge
von `\mathbb{Z}`, aber eine
`isomorphe <http://de.wikipedia.org/wiki/Homomorphismus#Universelle_Algebra>`_
`Einbettung <http://de.wikipedia.org/wiki/Einbettung_(Mathematik)>`_.

.. admonition:: Hinweis

    Eine Einführung von `\mathbb{Z}`, die versucht ausgehend von `\mathbb{N}`
    möglichst wenig neue Objekte zu verwenden, eben auch kein `+` und `-`, ist die
    über **Äquivalenzklassen** (:lnk:`r.co`) von Zahlenpaaren `(n,m)` aus
    `\mathbb{N}` mit der Äquivalenzrelation `(n_1,m_1)\sim(n_2,m_2)\equiv n_1+m_2=n_2+m_1`.
    In der kanonischen Darstellung ist eine Zahl des Paares 0.
    `+2 = (2,0)` und `-2 = (0,2)`.

Mit `+` und `-` als Vorgänge kann man sich die *Addition* algorithmisch als eine Sequenz denken:
das hintereinander Ausführen von Hinzugeben oder Wegnehmen.
`+2+(-2)` heißt 2 hinzugeben und dann 2 wegnehmen.
Vertauscht `((-2)+(+2))` erhält man das gleiche Ergebnis (**Kommutativgesetz**).
Bei mehreren Zahlen kann frei entscheiden, was man zuerst berechnet
`(-2)+((+2)+(+3))=((-2)+(+2))+(+3)` (**Assoziativgesetz**).

.. admonition:: Hinweis

    Die Subtraktion 2-2 ist eine Kurzschreibweise für +2+(-2).

Das Ergebnis von +2+(-2)= 0, das **neutrale Element** der Addition.
+2 ist die **Gegenzahlen** (inverses Element der Addition) von -2 und umgekehrt.
`(\mathbb{Z},+)` ist ein **abelsche Gruppe** (:lnk:`r.cl`).

.. admonition:: Hinweis

    `+` als Teil der Zahl und `+` als binäre Operation meinen nicht dasselbe,
    ebenso für `-`. `-` kann zusätzlich als unitäre Operation (Funktion) angesehen werden,
    welche die Gegenzahl liefert.

Die ganzen Zahlen `\mathbb{Z}` und die Multiplikation
-----------------------------------------------------

Einen Vorgang kann man wiederholen.  Die Multiplikation gibt an, wie oft das
Hinzugeben (+2) oder Wegnehmen (-2) wiederholt wird.  Multiplikation stellt
also algorithmisch eine Schleife dar:

    `3\cdot(-2) = (-2)+(-2)+(-2)`

Die Multiplikation mit 1 heißt einmal wiederholt, also das Ding selbst und unverändert.
1 ist das **neutrale Element** der Multiplikation.

Der Multiplikation mit -1 gibt man die Bedeutung: Umkehrung des wiederholten Vorgangs,
d.h. aus hinzu (+) mach weg (-).

    `(-1)\cdot(-2) = +2`

    `(-1)\cdot(-1)\cdot(-2) = -2`

Damit kann man jede ganze Zahl mit jeder anderen ganzen Zahl multiplizieren und es kommt
wieder eine ganze Zahl heraus, d.h. eine Anzahl die man hinzugibt oder wegnimmt.
`(\mathbb{Z},\cdot)` ist bezüglich der Multiplikation **abgeschlossen** und es gilt das
**Assoziativegesetz**.

`(\mathbb{Z},+,\cdot)` ist ein **Integritätsring** (:lnk:`r.cm`).

`(\mathbb{N},+,\cdot)` alleine ist nur ein **Halbring** (:lnk:`r.cm`) .


Die Multiplikation und die Rationalen Zahlen (`\mathbb{Q}`)
-----------------------------------------------------------

Analog zu `\mathbb{Z}=\mathbb{N}\times\{+,-\}` kann man sich
das Wiederholen/Vervielfachen vereint mit der Anzahl als neues Element denken.
Dann ist es naheliegend, dass man diesen Vorgang umkehren möchte.

Welches Wegnehmen muss ich 3 mal wiederholen, damit (-6) herauskommt?:

    (-6)/3 = -2

Analog zu `\mathbb{Z}=\mathbb{N}\times\{+,-\}` kann man über
`\mathbb{N}\times\{\cdot,\div\}` mit Anzahl Multiplikation und Division vereinen.

Beides sind unterschiedliche Mengen.  Man muss also grundsätzlich die binären
Verknüpfungen `\cdot` und `+` getrennt behandeln.  Nur das
**Distributivgesetz** vereint die beiden:

    `a\cdot(b+c) = a\cdot b + a\cdot c`

    z.B. `2\cdot(3+4)=2\cdot 3+2\cdot 4=14`

Wenn man im speziellen nach dem Teil sucht, der wiederholt (multipliziert)
nichts verändert, also 1 ergibt, so kommt man auf den **Kehrwert** (**Reziprok**) und
der meint die UmKEHRung des Wiederholens, das **inverse Element der Multiplikation**.

Während bei (-6)/3 noch eine ganze Zahl herauskommt, d.h. ein Vielfaches von 1,
ist das beim Kehrwert nicht mehr der Fall.

Es ist naheliegend die Wiederholungen mit deren Umkehrungen zu erweitern.
Dieser Schritt kann in Analogie zur Erweiterung von `\mathbb{N}` auf `\mathbb{Z}` gesehen werden.

- Dort wurde der Vorgang "hinzu" mit der Anzahl vereint zum Paar (Anzahl,hinzu).
  "hinzu" hat eine Umkehrung, dem "weg".
  Man hat (Anzahl,weg) erweitert.

- In `\mathbb{Q}` erweitert man (Anzahl,vervielfachen) mit *Kehrzahlen* (Anzahl,teilen).

.. admonition:: Hinweis

    Man könnte `\mathbb{Q}`-Elemente analog zu `\mathbb{N}\times\{+,-\}`
    schreiben:

    - `\cdot 2` entspräche +2 und
    - `\div 2` entspräche -2

    Die binäre Verknüpfung `\cdot` ist wieder nur Hintereinander-Ausführen und kann weggelassen werden

    `(\cdot 2)\cdot(\div 2) = \cdot 2\div 2 = 1`

    Stattdessen wird

    - `2\cdot 2^{-1} = 1` oder
    - `2\cdot \frac{1}{2} = 1`

    geschrieben, ersteres, weil man die Hochzahlen bei gleicher
    Basis addieren kann und somit `2\cdot 2^{-1}=2^1\cdot 2^{-1}=2^{1-1}=2⁰=1` ist.


`(\mathbb{Q},\cdot)` ist eine **abelsche Gruppe** mit dem neutralen Element 1.

Weil jede Multiplikation in `(\mathbb{Q},\cdot)` ein Ergebnis in
`(\mathbb{Q},\cdot)` liefern soll (Abgeschlossenheit), nimmt man alle Brüche
`p/q=pq^{-1}` in `(\mathbb{Q},\cdot)` auf.
3/2 heißt, dass man zuert `\cdot 3` und dann `\div 2` (Kehrwert von 2) macht.

    `\frac{3}{2}=3\cdot 2^{-1}=3\frac{1}{2}=\frac{1}{2}\cdot 3=2^{-1}\cdot 3`

`pq^{-1}` bedeutet, dass man p mal vervielfacht und dann q mal teilt.
Wenn man zusätzlich eine gleiche Anzahl r mal wiederholt und dann wieder r mal teilt,
ändert sich nichts

    `pq^{-1}=rr^{-1}pq^{-1}=rp(rq)^{-1}=\frac{rp}{rq}`

Alle solche Zahlen sind äquivalent und die kanonische Darstellung ist die mit p und q teilerfremd.

.. admonition:: Hinweis

    `\mathbb{Q}` wird formal über Äquivalenzklassen
    solcher gleichwertiger Zahlenpaare eingeführt:
    `(n_1,n_2)\sim(n_2,m_2)\equiv n_1m_2=n_2m_1`.


`\mathbb{R}` als Erweiterung mit den irrationalen Zahlen `\mathbb{I}`
---------------------------------------------------------------------

Anzahl (`\mathbb{N}`) mit Hinzugeben (+) und Wegnehmen (-) ist `\mathbb{Z}`.
`\mathbb{Z}` mit Wiederholen (`\cdot`) und Teilen (`\div`) führt zu `\mathbb{Q}`.
Wenn wir bei `+,-,\cdot,\div` bleiben, kommen wir gut mit `\mathbb{Q}` aus.

Soll die Operation des Potenzierens umkehrbar sein, muss man wieder erweitern,
da es sich herausstellt, dass es
z.B. kein `p/q` in `\mathbb{Q}` gibt, für das `p^2/q^2=2` ist.
(Beweis: p/q teilerfremd. Wenn `p^2` gerade, dann auch p. Also `p=2n`, womit
`p^2=4n^2=2q^2` und damit q gerade, was ein Widerspruch ist).

Es gibt aber **Algorithmen**, die rationale Zahlen erzeugen (**Zahlenfolge**),
deren Quadrate immer näher an 2 heranreichen.
Es gibt mehrere solcher Algorithmen, also mehrere Zahlenfolgen, deren **Grenzwert** 2 ist.
Alle zusammen werden als Äquivalenzklasse angesehen.

Die irrationalen Zahlen `\mathbb{I}` besteht aus Äquivalenzklasse von Zahlenfolgen.
Durch Angabe des Algorithmus, und mit `\sqrt{}` meint man so einen Algorithmus,
ist die irrationale Zahl bestimmt.
Man kann eine irrationale Zahl nicht als Dezimalzahl schreiben.
Man kann den Algorithmus auch nie vollständig ausführen, denn der endet nie.
Damit ist die irrationale Zahl wirklich dieser Algorithmus.

Die irrationalen Zahlen werden noch unterteilt in **algebraische** irrationale Zahlen,
eben solche die mit potenzieren zu tun haben,
und den **transzendente** irrationale Zahlen.
Letztere gibt es, weil es nicht nur Potenzieren gibt, sondern viele andere Abhängigkeiten,
etwa Sin, Cos, ...

Neue Operationen/Funktionen führen zu neuen Zahlen.  Mit den irrationalen
Zahlen als **Äquivalenzklasse von Zahlenfolgen** hat man aber eine Definition,
die so allgemein ist, dass alle algebraischen und auch alle transzendenten
Zahlen und auch `\mathbb{Q}` mit eingeschlossen sind.

    `\mathbb{R} = \mathbb{Q} \cup \mathbb{I}`

Eine andere sehr brauchbare und faszinierende Erweiterung sind die Komplexen Zahlen `\mathbb{C}` (:lnk:`r.di`).

.. admonition:: Hinweis

    Da `\mathbb{R}` unendliche Zahlenfolgen sind, könnte man auch `\infty` und
    `-\infty` als Zahlen mit aufnehmen, wären da nicht `\infty+1=\infty` und dergleichen.
    Nichtsdestotrotz wird in der komplexen Analysis (Funktionentheorie)
    `\mathbb{C}` mit `\infty` fruchtbar erweitert.


<file_sep>/chcko/r/cs/en.rst
.. raw:: html

    %path = "maths/morphisms"
    %kind = chindnum["texts"]
    %level = 10
    <!-- html -->

The concept of a function from set theory that maps uniquely elements of one set
(domain) to elements of another set (codomain),
is tweaked/generalized with the concept of morphism in category theory
in the sense that it puts the whole mapping in the center and combines
all objects whether domain or codomain into a set of objects O.
Domain and codomain in the set of objects are determined or part of a
morphism (`D_f` is domain of f, `C_f` is codomain of f, both do not need to be sets).
More morphisms in the set of morphisms M can share the
same pair (domain, codomain). (O,M,id) is a category. id is the identity morphism.

An important aspect of a morphism is that it maintains the structure in the objects
(order structure, algebraic structure, topological structure) and
depending on the structure the morphisms have special names (`f\circ g (D_g) = f(g(D_g))`):

- Monomorphism: `f\circ g=f\circ h \implies g=h` (left cancellation of `f`)
  or `f` injective for set objects
  (`proof <http://www.proofwiki.org/wiki/Injection_iff_Monomorphism_in_Category_of_Sets>`_)

- Epimorphism: `g\circ f=h \circ f \implies g=h` (right cancellation)
  or `f` surjective for set objects
  (`proof <http://www.proofwiki.org/wiki/Surjection_iff_Epimorphism_in_Category_of_Sets>`_)

- Isomorphism: `f` has `g` such that `f\circ g=id_{D_g}` and `g \circ f = id_{D_f}`
  (left inverse = right inverse) or `f` bijektive for set objects

- Endomorphism: `X\rightarrow X`

- Automorphism: `X\rightarrow X` + isomorphism

- Homomorphism (Algebra): `f(a+b)=f(a)+f(b)` (different `+` possible)

- Homeomorphism (Topology): `f` and `f^{-1}` continuous

- Diffeomorphism (Differential geometry): bijektive, `f` and `f^{-1}` continuously differentiable



<file_sep>/chcko/r/a0/en.rst
.. raw:: html

    %path = "maths/vectors"
    %kind = chindnum["texts"]
    %level = 11
    <!-- html -->

If we see the ingredients of a set of cake recipes as vector space,
then every cake `z` is a vector of the *ingredient vector space*.
We independently choose an amount from each ingredient (variable `z_i`).
We use the value 0, if the ingredient is not used at all.

If we only look at the cakes,
then a choice from them is a vector `k` in the *cake vector space*.
Every `k_j` is the number of cakes of kind `j`.

When going from the cakes to the ingredients,
one does a coordinate transformation.
To get the total amount of ingredient `z_i`
one needs to multiply the number of each cake `k_j`
with the amount of ingredient `i` for that cake.
This is a matrix multiplication.

`z = ZK \cdot k = \sum_j ZK_{ij}k_j`

In `ZK` every column is a recipe,
i.e. the ingredients (**components**) for cake `j`.

To obtain the price `p` in the *price vector space*,
i.e. what is the cost of all ingredients for a set of cakes,
we multiply again

`p = PZ \cdot z = PZ_{1i} z_i`

`PZ` is a matrix with one row.
The number of rows is the dimension of the target vector space.

<file_sep>/chcko/r/bs/__init__.py
# -*- coding: utf-8 -*-
from random import sample
from chcko.chcko.hlp import Struct, equal_0 as equal, norm_expr as chorm

import sympy
from sympy import S, sin, cos, E
from sympy.abc import x


def chiven():
    f = sample([E ** x, sin(x), cos(x), 1 / x], 1)[0]
    a, b = sample(range(2, 9), 2)
    ee = f.subs(x, a * x + b)
    g = Struct(ee=sympy.sstr(ee))
    return g


def chalc(g):
    res = sympy.sstr(S(sympy.integrate(S(g.ee), x)))
    return [res]
<file_sep>/chcko/r/dj/en.rst
.. raw:: html

    %path = "maths/trigonometry"
    %kind = chindnum["texts"]
    %level = 11
    <!-- html -->

.. role:: asis(raw)
    :format: html latex

.. contents::

In the following drawing we have a circle with radius 1.
The length of the arc on such a circle is a measure for the **angle**.
It is called **radian** and the unit is ``rad``. The right angle (90°) is `\pi/2`.
In general

.. math::

    \frac{\pi}{180}\alpha[°] = \alpha[rad]

By changing this angle one also changes the lengths labeled with `\sin\alpha`,
`\cos\alpha` and `\tan\alpha`. These lengths are determined by the angle,
which is equivalent to say that the lengths are **functions of the angle**.

.. tikz:: \coordinate (O) at (0,0);
        \coordinate (C) at ({2*cos(60)},{2*sin(60)});
        \coordinate (P) at ({2*cos(60)},0);
        \coordinate (D) at (2,{2*tan(60)});
        \draw[black, very thin] (O) circle [radius=2];
        \draw[red,thick] (2,0) arc [radius=2, start angle=0, end angle=60] node[midway,above]{\tiny $\alpha$};
        \draw[blue,thick] (O) -- (C) node[midway,above]{\tiny $1$};
        \draw[blue,thick] (P) -- (C) node[midway,right]{\tiny $\sin\alpha$};
        \draw[blue,thick] (O) -- (P) node[midway,below]{\tiny $\cos\alpha$};
        \draw[green,thick] (P) -- (2,0);
        \draw[green,thick] (2,0) -- (D) node[midway,right]{\tiny $\tan\alpha$};
        \draw[green,thick] (C) -- (D);
        \draw[xshift=-1.1cm,yshift=-1cm] node[right,text width=2.2cm]
        { \tiny $\tan\alpha=\frac{\sin\alpha}{\cos\alpha}$\\$\sin^2\alpha+\cos^2\alpha=1$ };


.. admonition:: Similarity = affine mapping

    One can scale this diagram to an actual rectangular triangle and completely
    determine it by knowing one sharp angle and one side.

The graphs of the above **trigonometric functions** are as follows


.. tikz:: \begin{axis}
        [
        ymin=-1,ymax=1,
        xmin=0,xmax=2*pi,
        xtick=\empty,
        ytick={-1,0,1},
        extra x ticks={1.5708,3.1416,4.712,6.2832},
        extra x tick labels={$\frac{\pi}{2}$, $\pi$, $\frac{3\pi}{2}$, $2\pi$},
        every extra x tick/.style={
                xticklabel style={anchor=north west},
                grid=major,
                major grid style={thick,dashed,red}
        },
        axis lines = center,
        xlabel=$x$,ylabel=$y$,
        enlargelimits=0.2,
        domain=0:2*pi,
        samples=100,
        axis equal,
        ]
        \addplot [green,thick] {tan(deg(x))} node [midway,left]{tan};
        \addplot [red,thick] {sin(deg(x))} node [above]{sin};
        \addplot [blue,thick] {cos(deg(x))} node [above]{cos};
    \end{axis}

Some values of the functions can be found via calculations on the equal sided triangle
(`\pi/3`, `\pi/6`) or on a square with side length 1 (`\pi/4`).

`\cos` is symmetric: `\cos(-\alpha)=\cos\alpha`

`\sin` is antisymmetric: `\sin(-\alpha)=-\sin\alpha`.

All trigonometric functions have a period of `2\pi`: `sin|cos|tan(\alpha+2\pi)=sin|cos|tan(\alpha)`.

Because the sharp angles of the rectangular triangle add to `\pi/2`, we have

.. math::
    \sin(\pi/2 - \alpha)=\cos\alpha\\
    \cos(\pi/2 - \alpha)=\sin\alpha

<file_sep>/chcko/r/bk/__init__.py
# -*- coding: utf-8 -*-
from random import randrange
from chcko.chcko.hlp import Struct, norm_int, norm_rounded
import numpy as np

__all__ = ['chiven', 'chorm', 'chalc', 'T']


def chiven():
    g = Struct()
    r2 = lambda v: round(
        randrange(int(v * 100 - v * 10), int(v * 100 + v * 10)) / 100.0, 2)
    r15 = lambda: randrange(1, 5)
    rr = lambda a, b: randrange(a, b)
    g.CC = [r15(), r15(), r15()]
    g.PP = [r2(1.8), r2(1), r2(0.3), r2(2.6)]
    g.RR = [[r2(80 / 250.0), r2(220 / 1000.0), rr(7, 10),
            r2(220 / 500.0)], [r2(150 / 250.0),
            r2(250 / 1000.0), rr(1, 3), r2(300 / 500.0)],
            [r2(70 / 250.0), r2(100 / 1000.0), rr(7, 9), 0]]
    return g

T = lambda x: np.transpose(np.array(x))


def chalc(g):
    npR = T(g.RR)
    npM = np.array(g.PP)
    npC = np.array(g.CC)
    ingr = np.dot(npR, npC)
    money = np.dot(npM, ingr)
    return [int(ingr[2]), money]


def chorm(answers):
    return [norm_int(answers[0]), norm_rounded(answers[1])]
