NumCpp-Download – Download des NumCpp-Quellcodes

NumCpp

Python

Release Version 2.12.1

Herunterladen

NumCpp: Eine C++-Implementierung der Python-NumPy-Bibliothek, die nur auf Vorlagen basiert

Autor: David Pilger [email protected]

Version:

Lizenz

Testen

C++-Standards:

Compiler:
Visual Studio: 2022
GNU: 11.3 Clang: 14

Boost-Versionen:
1,73+

Dokumentation

GitHub

Installation

Gebäude

Versionshinweise

Von NumPy zu NumCpp – Eine Kurzanleitung

Diese Kurzanleitung soll einen sehr kurzen Überblick über einige Dinge geben, die mit NumCpp erledigt werden können. Eine vollständige Aufschlüsselung aller in der NumCpp -Bibliothek verfügbaren Informationen finden Sie in der vollständigen Dokumentation.

BEHÄLTER

Die Hauptdatenstruktur in NumCpp ist das NdArray . Es handelt sich von Natur aus um eine 2D-Array-Klasse, wobei 1D-Arrays als 1xN-Arrays implementiert werden. Es gibt auch eine DataCube -Klasse, die als praktischer Container zum Speichern eines Arrays von 2D- NdArray -Objekten bereitgestellt wird, aber über einen einfachen Container hinaus nur begrenzt nützlich ist.

NumPy	NumCpp
`a = np.array([[1, 2], [3, 4], [5, 6]])`	`nc::NdArray a = { {1, 2}, {3, 4}, {5, 6} }`
`a.reshape([2, 3])`	`a.reshape(2, 3)`
`a.astype(np.double)`	`a.astype()`

INITIALISIERER

Es werden viele Initialisierungsfunktionen bereitgestellt, die NdArray s für allgemeine Anforderungen zurückgeben.

NumPy	NumCpp
`np.linspace(1, 10, 5)`	`nc::linspace(1, 10, 5)`
`np.arange(3, 7)`	`nc::arange(3, 7)`
`np.eye(4)`	`nc::eye(4)`
`np.zeros([3, 4])`	`nc::zeros(3, 4)`
	`nc::NdArray(3, 4) a = 0`
`np.ones([3, 4])`	`nc::ones(3, 4)`
	`nc::NdArray(3, 4) a = 1`
`np.nans([3, 4])`	`nc::nans(3, 4)`
	`nc::NdArray(3, 4) a = nc::constants::nan`
`np.empty([3, 4])`	`nc::empty(3, 4)`
	`nc::NdArray(3, 4) a`

Slicing/Rundfunk

NumCpp bietet Slicing und Broadcasting im NumPy- Stil.

NumPy	NumCpp
`a[2, 3]`	`a(2, 3)`
`a[2:5, 5:8]`	`a(nc::Slice(2, 5), nc::Slice(5, 8))`
	`a({2, 5}, {5, 8})`
`a[:, 7]`	`a(a.rSlice(), 7)`
`a[a > 5]`	`a[a > 5]`
`a[a > 5] = 0`	`a.putMask(a > 5, 0)`

ZUFÄLLIG

Das Zufallsmodul bietet einfache Möglichkeiten zum Erstellen zufälliger Arrays.

NumPy	NumCpp
`np.random.seed(666)`	`nc::random::seed(666)`
`np.random.randn(3, 4)`	`nc::random::randN(nc::Shape(3, 4))`
	`nc::random::randN({3, 4})`
`np.random.randint(0, 10, [3, 4])`	`nc::random::randInt(nc::Shape(3, 4), 0, 10)`
	`nc::random::randInt({3, 4}, 0, 10)`
`np.random.rand(3, 4)`	`nc::random::rand(nc::Shape(3,4))`
	`nc::random::rand({3, 4})`
`np.random.choice(a, 3)`	`nc::random::choice(a, 3)`

VERKETTUNG

Es stehen viele Möglichkeiten zur Verkettung von NdArray zur Verfügung.

NumPy	NumCpp
`np.stack([a, b, c], axis=0)`	`nc::stack({a, b, c}, nc::Axis::ROW)`
`np.vstack([a, b, c])`	`nc::vstack({a, b, c})`
`np.hstack([a, b, c])`	`nc::hstack({a, b, c})`
`np.append(a, b, axis=1)`	`nc::append(a, b, nc::Axis::COL)`

DIAGONAL, DREIECKIG UND FLIP

Die folgenden geben neue NdArray s zurück.

NumPy	NumCpp
`np.diagonal(a)`	`nc::diagonal(a)`
`np.triu(a)`	`nc::triu(a)`
`np.tril(a)`	`nc::tril(a)`
`np.flip(a, axis=0)`	`nc::flip(a, nc::Axis::ROW)`
`np.flipud(a)`	`nc::flipud(a)`
`np.fliplr(a)`	`nc::fliplr(a)`

ITERATION

NumCpp folgt den Redewendungen der C++-STL und stellt Iteratorpaare bereit, um Arrays auf unterschiedliche Weise zu iterieren.

NumPy	NumCpp
`for value in a`	`for(auto it = a.begin(); it < a.end(); ++it)`
	`for(auto& value : a)`

LOGISCH

Logische FUNKTIONEN in NumCpp verhalten sich genauso wie NumPy .

NumPy	NumCpp
`np.where(a > 5, a, b)`	`nc::where(a > 5, a, b)`
`np.any(a)`	`nc::any(a)`
`np.all(a)`	`nc::all(a)`
`np.logical_and(a, b)`	`nc::logical_and(a, b)`
`np.logical_or(a, b)`	`nc::logical_or(a, b)`
`np.isclose(a, b)`	`nc::isclose(a, b)`
`np.allclose(a, b)`	`nc::allclose(a, b)`

VERGLEICH

NumPy	NumCpp
`np.equal(a, b)`	`nc::equal(a, b)`
	`a == b`
`np.not_equal(a, b)`	`nc::not_equal(a, b)`
	`a != b`
`rows, cols = np.nonzero(a)`	`auto [rows, cols] = nc::nonzero(a)`

MINIMUM, MAXIMUM, SORTIERUNG

NumPy	NumCpp
`np.min(a)`	`nc::min(a)`
`np.max(a)`	`nc::max(a)`
`np.argmin(a)`	`nc::argmin(a)`
`np.argmax(a)`	`nc::argmax(a)`
`np.sort(a, axis=0)`	`nc::sort(a, nc::Axis::ROW)`
`np.argsort(a, axis=1)`	`nc::argsort(a, nc::Axis::COL)`
`np.unique(a)`	`nc::unique(a)`
`np.setdiff1d(a, b)`	`nc::setdiff1d(a, b)`
`np.diff(a)`	`nc::diff(a)`

REDUZIERGERÄTE

Reduzierer akkumulieren Werte von NdArray s entlang bestimmter Achsen. Wenn keine Achse angegeben ist, werden die Werte entlang aller Achsen akkumuliert.

NumPy	NumCpp
`np.sum(a)`	`nc::sum(a)`
`np.sum(a, axis=0)`	`nc::sum(a, nc::Axis::ROW)`
`np.prod(a)`	`nc::prod(a)`
`np.prod(a, axis=0)`	`nc::prod(a, nc::Axis::ROW)`
`np.mean(a)`	`nc::mean(a)`
`np.mean(a, axis=0)`	`nc::mean(a, nc::Axis::ROW)`
`np.count_nonzero(a)`	`nc::count_nonzero(a)`
`np.count_nonzero(a, axis=0)`	`nc::count_nonzero(a, nc::Axis::ROW)`

E/A

Druck- und Dateiausgabemethoden. Alle NumCpp -Klassen unterstützen eine print() Methode und << Stream-Operatoren.

NumPy	NumCpp
`print(a)`	`a.print()`
	`std::cout << a`
`a.tofile(filename, sep='n')`	`a.tofile(filename, 'n')`
`np.fromfile(filename, sep='n')`	`nc::fromfile(filename, 'n')`
`np.dump(a, filename)`	`nc::dump(a, filename)`
`np.load(filename)`	`nc::load(filename)`

MATHEMATISCHE FUNKTIONEN

NumCpp- Universalfunktionen werden für eine große Anzahl mathematischer Funktionen bereitgestellt.

GRUNDFUNKTIONEN

NumPy	NumCpp
`np.abs(a)`	`nc::abs(a)`
`np.sign(a)`	`nc::sign(a)`
`np.remainder(a, b)`	`nc::remainder(a, b)`
`np.clip(a, 3, 8)`	`nc::clip(a, 3, 8)`
`np.interp(x, xp, fp)`	`nc::interp(x, xp, fp)`

EXPONENTIALFUNKTIONEN

NumPy	NumCpp
`np.exp(a)`	`nc::exp(a)`
`np.expm1(a)`	`nc::expm1(a)`
`np.log(a)`	`nc::log(a)`
`np.log1p(a)`	`nc::log1p(a)`

POWER-FUNKTIONEN

NumPy	NumCpp
`np.power(a, 4)`	`nc::power(a, 4)`
`np.sqrt(a)`	`nc::sqrt(a)`
`np.square(a)`	`nc::square(a)`
`np.cbrt(a)`	`nc::cbrt(a)`

TRIGONOMETRISCHE FUNKTIONEN

NumPy	NumCpp
`np.sin(a)`	`nc::sin(a)`
`np.cos(a)`	`nc::cos(a)`
`np.tan(a)`	`nc::tan(a)`

HYPERBOLISCHE FUNKTIONEN

NumPy	NumCpp
`np.sinh(a)`	`nc::sinh(a)`
`np.cosh(a)`	`nc::cosh(a)`
`np.tanh(a)`	`nc::tanh(a)`

KLASSIFIZIERUNGSFUNKTIONEN

NumPy	NumCpp
`np.isnan(a)`	`nc::isnan(a)`
`np.isinf(a)`	`nc::isinf(a)`

LINEARE ALGEBRA

NumPy	NumCpp
`np.linalg.norm(a)`	`nc::norm(a)`
`np.dot(a, b)`	`nc::dot(a, b)`
`np.linalg.det(a)`	`nc::linalg::det(a)`
`np.linalg.inv(a)`	`nc::linalg::inv(a)`
`np.linalg.lstsq(a, b)`	`nc::linalg::lstsq(a, b)`
`np.linalg.matrix_power(a, 3)`	`nc::linalg::matrix_power(a, 3)`
`Np.linalg.multi_dot(a, b, c)`	`nc::linalg::multi_dot({a, b, c})`
`np.linalg.svd(a)`	`nc::linalg::svd(a)`

Expandieren

Zusätzliche Informationen

Version Release Version 2.12.1
Typ Python
Aktualisierungszeit 2024-12-11
Größe 7.34MB
Sprache Vereinfachtes Chinesisch