# Python numpy.norm() Examples

The following are 11 code examples for showing how to use numpy.norm(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example.

You may check out the related API usage on the sidebar.

You may also want to check out all available functions/classes of the module , or try the search function .

Example 1
 Project: quaternion   Author: moble   File: __init__.py    License: MIT License 6 votes  ```def as_rotation_vector(q):
"""Convert input quaternion to the axis-angle representation

Note that if any of the input quaternions has norm zero, no error is
raised, but NaNs will appear in the output.

Parameters
----------
q: quaternion or array of quaternions
The quaternion(s) need not be normalized, but must all be nonzero

Returns
-------
rot: float array
Output shape is q.shape+(3,).  Each vector represents the axis of
the rotation, with norm proportional to the angle of the rotation in

"""
return as_float_array(2*np.log(np.normalized(q)))[..., 1:] ```
Example 2
 Project: quaternion   Author: moble   File: __init__.py    License: MIT License 6 votes  ```def from_rotation_vector(rot):
"""Convert input 3-vector in axis-angle representation to unit quaternion

Parameters
----------
rot: (Nx3) float array
Each vector represents the axis of the rotation, with norm
proportional to the angle of the rotation in radians.

Returns
-------
q: array of quaternions
Unit quaternions resulting in rotations corresponding to input
rotations.  Output shape is rot.shape[:-1].

"""
rot = np.array(rot, copy=False)
quats = np.zeros(rot.shape[:-1]+(4,))
quats[..., 1:] = rot[...]/2
quats = as_quat_array(quats)
return np.exp(quats) ```
Example 3
 Project: quaternion   Author: moble   File: test_quaternion.py    License: MIT License 6 votes  ```def test_as_euler_angles():
np.random.seed(1843)
random_angles = [[np.random.uniform(-np.pi, np.pi),
np.random.uniform(-np.pi, np.pi),
np.random.uniform(-np.pi, np.pi)]
for i in range(5000)]
for alpha, beta, gamma in random_angles:
R1 = quaternion.from_euler_angles(alpha, beta, gamma)
R2 = quaternion.from_euler_angles(*list(quaternion.as_euler_angles(R1)))
d = quaternion.rotation_intrinsic_distance(R1, R2)
assert d < 6e3*eps, ((alpha, beta, gamma), R1, R2, d)  # Can't use allclose here; we don't care about rotor sign
q0 = quaternion.quaternion(0, 0.6, 0.8, 0)
assert q0.norm() == 1.0
assert abs(q0 - quaternion.from_euler_angles(*list(quaternion.as_euler_angles(q0)))) < 1.e-15

# Unary bool returners ```
Example 4
 Project: quaternion   Author: moble   File: test_quaternion.py    License: MIT License 5 votes  ```def test_quaternion_square(Qs):
square_precision = 1.e-15
for q in Qs[Qs_finite]:
assert np.norm(q*q - q**2) < square_precision
a = np.array([q])
assert np.norm(a**2 - np.array([q**2])) < square_precision ```
Example 5
 Project: discretize   Author: simpeg   File: Tests.py    License: MIT License 5 votes  ```def getError(self):
"""For given h, generate A[h], f and A(f) and return norm of error."""
return 1. ```
Example 6
 Project: abcpy   Author: eth-cscs   File: pmcabc-gaussian_model_simple.py    License: BSD 3-Clause Clear License 5 votes  ```def pdf(self, input_values, x):
mu = input_values
sigma = input_values
pdf = np.norm(mu, sigma).pdf(x)
return pdf ```
Example 7
 Project: abcpy   Author: eth-cscs   File: pmcabc_gaussian_model_simple.py    License: BSD 3-Clause Clear License 5 votes  ```def pdf(self, input_values, x):
mu = input_values
sigma = input_values
pdf = np.norm(mu,sigma).pdf(x)
return pdf ```
Example 8
 Project: abcpy   Author: eth-cscs   File: gaussian_model.py    License: BSD 3-Clause Clear License 5 votes  ```def pdf(self, input_values, x):
mu = input_values
sigma = input_values
pdf = np.norm(mu, sigma).pdf(x)
return pdf ```
Example 9
 Project: quaternion   Author: moble   File: __init__.py    License: MIT License 4 votes  ```def as_rotation_matrix(q):
"""Convert input quaternion to 3x3 rotation matrix

Parameters
----------
q: quaternion or array of quaternions
The quaternion(s) need not be normalized, but must all be nonzero

Returns
-------
rot: float array
Output shape is q.shape+(3,3).  This matrix should multiply (from
the left) a column vector to produce the rotated column vector.

Raises
------
ZeroDivisionError
If any of the input quaternions have norm 0.0.

"""
if q.shape == () and not isinstance(q, np.ndarray):  # This is just a single quaternion
n = q.norm()
if n == 0.0:
raise ZeroDivisionError("Input to `as_rotation_matrix({0})` has zero norm".format(q))
elif abs(n-1.0) < _eps:  # Input q is basically normalized
return np.array([
[1 - 2*(q.y**2 + q.z**2),   2*(q.x*q.y - q.z*q.w),      2*(q.x*q.z + q.y*q.w)],
[2*(q.x*q.y + q.z*q.w),     1 - 2*(q.x**2 + q.z**2),    2*(q.y*q.z - q.x*q.w)],
[2*(q.x*q.z - q.y*q.w),     2*(q.y*q.z + q.x*q.w),      1 - 2*(q.x**2 + q.y**2)]
])
else:  # Input q is not normalized
return np.array([
[1 - 2*(q.y**2 + q.z**2)/n,   2*(q.x*q.y - q.z*q.w)/n,      2*(q.x*q.z + q.y*q.w)/n],
[2*(q.x*q.y + q.z*q.w)/n,     1 - 2*(q.x**2 + q.z**2)/n,    2*(q.y*q.z - q.x*q.w)/n],
[2*(q.x*q.z - q.y*q.w)/n,     2*(q.y*q.z + q.x*q.w)/n,      1 - 2*(q.x**2 + q.y**2)/n]
])
else:  # This is an array of quaternions
n = np.norm(q)
if np.any(n == 0.0):
raise ZeroDivisionError("Array input to `as_rotation_matrix` has at least one element with zero norm")
else:  # Assume input q is not normalized
m = np.empty(q.shape + (3, 3))
q = as_float_array(q)
m[..., 0, 0] = 1.0 - 2*(q[..., 2]**2 + q[..., 3]**2)/n
m[..., 0, 1] = 2*(q[..., 1]*q[..., 2] - q[..., 3]*q[..., 0])/n
m[..., 0, 2] = 2*(q[..., 1]*q[..., 3] + q[..., 2]*q[..., 0])/n
m[..., 1, 0] = 2*(q[..., 1]*q[..., 2] + q[..., 3]*q[..., 0])/n
m[..., 1, 1] = 1.0 - 2*(q[..., 1]**2 + q[..., 3]**2)/n
m[..., 1, 2] = 2*(q[..., 2]*q[..., 3] - q[..., 1]*q[..., 0])/n
m[..., 2, 0] = 2*(q[..., 1]*q[..., 3] - q[..., 2]*q[..., 0])/n
m[..., 2, 1] = 2*(q[..., 2]*q[..., 3] + q[..., 1]*q[..., 0])/n
m[..., 2, 2] = 1.0 - 2*(q[..., 1]**2 + q[..., 2]**2)/n
return m ```
Example 10
 Project: quaternion   Author: moble   File: __init__.py    License: MIT License 4 votes  ```def as_euler_angles(q):
"""Open Pandora's Box

If somebody is trying to make you use Euler angles, tell them no, and
walk away, and go and tell your mum.

You don't want to use Euler angles.  They are awful.  Stay away.  It's
one thing to convert from Euler angles to quaternions; at least you're
moving in the right direction.  But to go the other way?!  It's just not
right.

Assumes the Euler angles correspond to the quaternion R via

R = exp(alpha*z/2) * exp(beta*y/2) * exp(gamma*z/2)

The angles are naturally in radians.

NOTE: Before opening an issue reporting something "wrong" with this
function, be sure to read all of the following page, *especially* the
very last section about opening issues or pull requests.
<https://github.com/moble/quaternion/wiki/Euler-angles-are-horrible>

Parameters
----------
q: quaternion or array of quaternions
The quaternion(s) need not be normalized, but must all be nonzero

Returns
-------
alpha_beta_gamma: float array
Output shape is q.shape+(3,).  These represent the angles (alpha,
beta, gamma) in radians, where the normalized input quaternion
represents `exp(alpha*z/2) * exp(beta*y/2) * exp(gamma*z/2)`.

Raises
------
AllHell
...if you try to actually use Euler angles, when you could have
been using quaternions like a sensible person.

"""
alpha_beta_gamma = np.empty(q.shape + (3,), dtype=np.float)
n = np.norm(q)
q = as_float_array(q)
alpha_beta_gamma[..., 0] = np.arctan2(q[..., 3], q[..., 0]) + np.arctan2(-q[..., 1], q[..., 2])
alpha_beta_gamma[..., 1] = 2*np.arccos(np.sqrt((q[..., 0]**2 + q[..., 3]**2)/n))
alpha_beta_gamma[..., 2] = np.arctan2(q[..., 3], q[..., 0]) - np.arctan2(-q[..., 1], q[..., 2])
return alpha_beta_gamma ```
Example 11
 Project: GridCal   Author: SanPen   File: numerical_power_flow.py    License: GNU General Public License v3.0 4 votes  ```def linearized_dc_power_flow(Ybus, Sbus, Ibus, V0, ref, pq, pv):
"""
Solves a DC power flow.
:param Ybus: Normal circuit admittance matrix
:param Sbus: Complex power injections at all the nodes
:param Ibus: Complex current injections at all the nodes
:param V0: Array of complex seed voltage (it contains the ref voltages)
:param ref: array of the indices of the slack nodes
:param pvpq: array of the indices of the non-slack nodes
:param pq: array of the indices of the pq nodes
:param pv: array of the indices of the pv nodes
:return:
Complex voltage solution
Converged: Always true
Solution error
Computed power injections given the found solution
"""

pvpq = np.r_[pv, pq].astype(int)

# Decompose the voltage in angle and magnitude
Va_ref = np.angle(V0[ref])  # we only need the angles at the slack nodes
Vm = np.abs(V0)

# initialize result vector
Va = np.empty(len(V0))

# reconvert the pqpv vector to a matrix so that we can call numpy directly with it
pvpq_ = np.matrix(pvpq)

# Compile the reduced imaginary impedance matrix
Bpqpv = Ybus.imag[pvpq_.T, pvpq_]
Bref = Ybus.imag[pvpq_.T, ref]

# compose the reduced power injections
# Since we have removed the slack nodes, we must account their influence as injections Bref * Va_ref
Pinj = Sbus[pvpq].real + (- Bref * Va_ref + Ibus[pvpq].real) * Vm[pvpq]

# update angles for non-reference buses
Va[pvpq] = spsolve(Bpqpv, Pinj)
Va[ref] = Va_ref

# re assemble the voltage
V = Vm * np.exp(1j * Va)

# compute the calculated power injection and the error of the voltage solution
Scalc = V * np.conj(Ybus * V - Ibus)

# compute the power mismatch between the specified power Sbus and the calculated power Scalc
mis = Scalc - Sbus  # complex power mismatch
F = np.r_[mis[pv].real, mis[pq].real, mis[pq].imag]  # concatenate again

# check for convergence
normF = np.linalg.norm(F, np.Inf)

return V, True, normF ```