I found a great solution by Paul Bourke. Here it is, implemented in JavaScript: function line_intersect(x1, y1, x2, y2, x3, y3, x4, y4) { var ua, ub, denom = (y4 – y3)*(x2 – x1) – (x4 – x3)*(y2 – y1); if (denom == 0) { return null; } ua = ((x4 – x3)*(y1 – y3) … Read more
I’ve implemented a function for applying np.dot to blocks that are explicitly read into core memory from the memory-mapped array: import numpy as np def _block_slices(dim_size, block_size): “””Generator that yields slice objects for indexing into sequential blocks of an array along a particular axis “”” count = 0 while True: yield slice(count, count + block_size, … Read more
The equations going from linear index to (i,j) index are i = n – 2 – floor(sqrt(-8*k + 4*n*(n-1)-7)/2.0 – 0.5) j = k + i + 1 – n*(n-1)/2 + (n-i)*((n-i)-1)/2 The inverse operation, from (i,j) index to linear index is k = (n*(n-1)/2) – (n-i)*((n-i)-1)/2 + j – i – 1 Verify in … Read more
If your number X falls between A and B, and you would like Y to fall between C and D, you can apply the following linear transform: Y = (X-A)/(B-A) * (D-C) + C That should give you what you want, although your question is a little ambiguous, since you could also map the interval … Read more
Some linear-algebra background Singular Value Decomposition (SVD) is a decomposition of any matrix W into three matrices: W = U S V* Where U and V are ortho-normal matrices, and S is diagonal with elements in decreasing magnitude on the diagonal. One of the interesting properties of SVD is that it allows to easily approximate … Read more
For each p between 0 and 1 then this will give you a point on the line segment: (x1, y1, z1) + p * ((x2, y2, z2) – (x1, y1, z1))
If you want to guarantee sorted-ascending values, just do an extra if ~issorted(diag(D)) [V,D] = eig(A); [D,I] = sort(diag(D)); V = V(:, I); end to sort them the way you want. Alternatively, use eigs: [V,D] = eigs(A,size(A,1)-1)
First, your 3rd row is linearly dependent with 1t and 2nd row. However, your 1st and 4th column are linearly dependent. Two methods you could use: Eigenvalue If one eigenvalue of the matrix is zero, its corresponding eigenvector is linearly dependent. The documentation eig states the returned eigenvalues are repeated according to their multiplicity and … Read more
You could factor the matrix into eigenvalues and eigenvectors. Then you get M = V * D * V^-1 Where V is the eigenvector matrix and D is a diagonal matrix. To raise this to the Nth power, you get something like: M^n = (V * D * V^-1) * (V * D * V^-1) … Read more
Here is an example showing how you can use numpy.linalg.lstsq for this task: import numpy as np x = np.linspace(0, 1, 20) y = np.linspace(0, 1, 20) X, Y = np.meshgrid(x, y, copy=False) Z = X**2 + Y**2 + np.random.rand(*X.shape)*0.01 X = X.flatten() Y = Y.flatten() A = np.array([X*0+1, X, Y, X**2, X**2*Y, X**2*Y**2, Y**2, … Read more