numerical-methods

In the figure below the goal is to compute the homography matrix H which transforms the points a1 a2 a3 a4 to their counterparts b1 b2 b3 b4. That is: [b1 b2 b3 b4] = H * [a1 a2 a3 a4] What way would you suggest to be the best way to calculate H(3x3). a1...b4 are points in 2D which are represented in homogeneous coordinate systems ( that is [a1_x a1_y 1]', ...). EDIT : For these types of problems we use SVD, So i would like to see how this can be simply done in Matlab. EDIT : Here is how I initially tried to solve it using svd (H=Q/P) in Maltlab. Cosider the following code for the given

I have been testing an algorithm that has been published in literature that involves solving a set of 'm' non-linear equations in both Matlab and Python. The set of non-linear equations involves input variables that contain complex numbers, and therefore the resulting solutions should also be complex. As of now, I have been able to get pretty good results in Matlab by using the following lines of code: lambdas0 = ones(1,m)*1e-5; options = optimset('Algorithm','levenberg-marquardt',... 'MaxFunEvals',1000000,'MaxIter',10000,'TolX',1e-20,... 'TolFun',1e-20); Eq = @(lambda)maxentfun(lambda,m,h,g);

I'm trying to make a simplified simulation of a 1-dimensional wave with a chain of harmonic oscillators. The differential equation for the position x[i] of the i-th oscillator (assuming equilibrium at x[i]=0 ) turns out to be - according to textbooks - this one: m*x[i]''=-k(2*x[i]-x[i-1]-x[i+1]) (the derivative is wrt the time) so i tried to numerically compute the dynamics with the following algorithm. Here osc[i] is the i-th oscillator as an object with attributes loc (absolute location), vel (velocity), acc (acceleration) and bloc (equilibrium location), dt is the time increment: for every

It is well known that adding up numbers can result in numerical errors (for example, if the first number is really large, whereas there are many other small numbers). This can be solved adding up the numbers in a non straight-forward way. See for example: https://en.wikipedia.org/wiki/Kahan_summation_algorithm Is numpy.sum implemented in such a way that numerical errors are avoided? hpaulj Searching on numpy kahan turned up a closed bug/issue https://github.com/numpy/numpy/issues/2448 Numerical-stable sum (similar to math.fsum) I haven't read it in detail. Note the reference to math.fsum fsum

I have polynomials of nontrivial degree (4+) and need to robustly and efficiently determine whether or not they have a root in the interval [0,T]. The precise location or number of roots don't concern me, I just need to know if there is at least one. Right now I'm using interval arithmetic as a quick check to see if I can prove that no roots can exist. If I can't, I'm using Jenkins-Traub to solve for all of the polynomial roots. This is obviously inefficient since it's checking for all real roots and finding their exact positions, information I don't end up needing. Is there a standard

I want to implement the Bessel functions of first and second kind Description of bessel functions for complex numbers in C++. Now I am looking for possibilities to introduce them in my source code. Since math.h only contains bessel functions for real numbers, I would be interested in seeing any kind of possibility. The Boost library implements ordinary Bessel functions of the first and second kind and modified Bessel functions of the first and second kind for both real and complex numbers (see documentation about Bessel functions ). Don't try to reinvent the wheel , just use the Boost