Making a matrix from numerical ranges: Difference between revisions
From Master of Neuroscience Wiki
Created page with "== The goal == Making a new matrix… Questions to [mailto:davrot@uni-bremen.de David Rotermund] Using '''import numpy as np''' is the standard. == Simple example – new [https://numpy.org/doc/stable/reference/generated/numpy.zeros.html np.zeros()] == Define the size of your new matrix with a tuple, e.g.<syntaxhighlight lang="python">M = numpy.zeros((DIM_0, DIM_1, DIM_2, …))</syntaxhighlight> === 1d === <syntaxhighlight lang="python">import numpy as np M = np...." |
No edit summary |
||
| (One intermediate revision by the same user not shown) | |||
| Line 1: | Line 1: | ||
Making a matrix from numerical ranges… | |||
Making a | |||
Questions to [mailto:davrot@uni-bremen.de David Rotermund] | Questions to [mailto:davrot@uni-bremen.de David Rotermund] | ||
== [https://numpy.org/doc/stable/reference/generated/numpy.arange.html numpy.arange] == | |||
<syntaxhighlight lang="python">numpy.arange([start, ]stop, [step, ]dtype=None, *, like=None)</syntaxhighlight><blockquote>Return evenly spaced values within a given interval. | |||
arange can be called with a varying number of positional arguments: | |||
'''arange(stop)''': Values are generated within the half-open interval [0, stop) (in other words, the interval including start but excluding stop). | |||
'''arange(start, stop)''': Values are generated within the half-open interval [start, stop). | |||
'''arange(start, stop, step)''' Values are generated within the half-open interval [start, stop), with spacing between values given by step. | |||
For integer arguments the function is roughly equivalent to the Python built-in range, but returns an ndarray rather than a range instance. | |||
'''When using a non-integer step, such as 0.1, it is often better to use numpy.linspace.'''</blockquote>Examples:<syntaxhighlight lang="python">import numpy as np | |||
<syntaxhighlight lang="python">import numpy as np | |||
print(np.arange(5)) # -> [0 1 2 3 4] | |||
print( | print(np.arange(0, 5)) # -> [0 1 2 3 4] | ||
print(np.arange(2, 5)) # -> [2 3 4] | |||
print(np.arange(0, 5, 2)) # -> [0 2 4]</syntaxhighlight>It can be nicely combined with '''reshape()''':<syntaxhighlight lang="python">import numpy as np | |||
print(np.arange(0, 9).reshape(3, 3))</syntaxhighlight>Output:<syntaxhighlight lang="python">[[0 1 2] | |||
[3 4 5] | |||
[6 7 8]]</syntaxhighlight>'''Do not use it with non-integer values for step!!!''' This can happen and you don’t want this to happen:<syntaxhighlight lang="python">import numpy as np | |||
print(np.arange(-3, 0, 0.5, dtype=int)) # -> [-3 -2 -1 0 1 2]</syntaxhighlight> | |||
== | == [https://numpy.org/doc/stable/reference/generated/numpy.linspace.html numpy.linspace] == | ||
<syntaxhighlight lang="python">numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)</syntaxhighlight><blockquote>Return evenly spaced numbers over a specified interval. | |||
Returns num evenly spaced samples, calculated over the interval [start, stop]. | |||
The endpoint of the interval can optionally be excluded.</blockquote><blockquote>'''start''': array_like | |||
The starting value of the sequence.</blockquote><blockquote>'''stop''': array_like | |||
The end value of the sequence, unless endpoint is set to False. In that case, the sequence consists of all but the last of num + 1 evenly spaced samples, so that stop is excluded. Note that the step size changes when endpoint is False.</blockquote><blockquote>'''num''': int, optional | |||
Number of samples to generate. Default is 50. Must be non-negative.</blockquote><blockquote>'''endpoint''': bool, optional | |||
If True, stop is the last sample. Otherwise, it is not included. Default is True.</blockquote>An example:<syntaxhighlight lang="python">import numpy as np | |||
print(np.linspace(0, 1, num=10, endpoint=False)) # -> [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9] | |||
print(np.arange(0, 10) / 10) # -> [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]</syntaxhighlight>Be mindful concerning the endpoint setting ('''Notice the … 8 10]'''):<syntaxhighlight lang="python">import numpy as np | |||
print( | print(np.linspace(0, 10, num=10, endpoint=False, dtype=int)) # -> [0 1 2 3 4 5 6 7 8 9] | ||
print(np.linspace(0, 10, num=10, endpoint=True, dtype=int)) # -> [ 0 1 2 3 4 5 6 7 8 10]</syntaxhighlight> | |||
== | == [https://numpy.org/doc/stable/reference/generated/numpy.logspace.html numpy.logspace] == | ||
<syntaxhighlight lang="python">numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)</syntaxhighlight><blockquote>Return numbers spaced evenly on a log scale. | |||
In linear space, the sequence starts at base ** start (base to the power of start) and ends with base ** stop (see endpoint below).</blockquote> | |||
Latest revision as of 14:18, 23 October 2025
Making a matrix from numerical ranges…
Questions to David Rotermund
numpy.arange
numpy.arange([start, ]stop, [step, ]dtype=None, *, like=None)
Return evenly spaced values within a given interval.
arange can be called with a varying number of positional arguments:
arange(stop): Values are generated within the half-open interval [0, stop) (in other words, the interval including start but excluding stop).
arange(start, stop): Values are generated within the half-open interval [start, stop).
arange(start, stop, step) Values are generated within the half-open interval [start, stop), with spacing between values given by step.
For integer arguments the function is roughly equivalent to the Python built-in range, but returns an ndarray rather than a range instance.
When using a non-integer step, such as 0.1, it is often better to use numpy.linspace.
Examples:
import numpy as np
print(np.arange(5)) # -> [0 1 2 3 4]
print(np.arange(0, 5)) # -> [0 1 2 3 4]
print(np.arange(2, 5)) # -> [2 3 4]
print(np.arange(0, 5, 2)) # -> [0 2 4]
It can be nicely combined with reshape():
import numpy as np
print(np.arange(0, 9).reshape(3, 3))
Output:
[[0 1 2]
[3 4 5]
[6 7 8]]
Do not use it with non-integer values for step!!! This can happen and you don’t want this to happen:
import numpy as np
print(np.arange(-3, 0, 0.5, dtype=int)) # -> [-3 -2 -1 0 1 2]
numpy.linspace
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
Return evenly spaced numbers over a specified interval.
Returns num evenly spaced samples, calculated over the interval [start, stop].
The endpoint of the interval can optionally be excluded.
start: array_like The starting value of the sequence.
stop: array_like The end value of the sequence, unless endpoint is set to False. In that case, the sequence consists of all but the last of num + 1 evenly spaced samples, so that stop is excluded. Note that the step size changes when endpoint is False.
num: int, optional Number of samples to generate. Default is 50. Must be non-negative.
endpoint: bool, optional If True, stop is the last sample. Otherwise, it is not included. Default is True.
An example:
import numpy as np
print(np.linspace(0, 1, num=10, endpoint=False)) # -> [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
print(np.arange(0, 10) / 10) # -> [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
Be mindful concerning the endpoint setting (Notice the … 8 10]):
import numpy as np
print(np.linspace(0, 10, num=10, endpoint=False, dtype=int)) # -> [0 1 2 3 4 5 6 7 8 9]
print(np.linspace(0, 10, num=10, endpoint=True, dtype=int)) # -> [ 0 1 2 3 4 5 6 7 8 10]
numpy.logspace
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)
Return numbers spaced evenly on a log scale. In linear space, the sequence starts at base ** start (base to the power of start) and ends with base ** stop (see endpoint below).
