# solve non-linear system of equations

I have a system of equations and I want to solve it to get x, y

$$\begin{cases} u= C_{1}+(x-C_{1})(1+k_{1}((x-C_{1})(x-C_{1})+(y-C_{2})(y-C_{2}))) \\ \\ v= C_{2}+(y-C_{2})(1+k_{2}((x-C_{1})(x-C_{1})+(y-C_{2})(y-C_{2}))) \end{cases}$$

If it possible I want to know how can it can be done in C++ too.

Update: Solve[] gives me very large output, so the problem is that I want to place solution in my C++ aplication and $C_1$, $C_2$, $k_1$, $k_2$ are variables. CForm[] doesn't help, I need more simple and suitable form for C++ to use.

• You've tried Solve[]? Aug 7, 2012 at 13:51
• @J.M. yes, I tried Solve but it gives me large and not optimised output,I want to place output in my c++ aplication, even using CForm not help, how to better optimise it? Aug 7, 2012 at 14:09
• @mrgloom The solution you get with Solve is almost useless. If you substitute parameters for certain values you'll get more useful results, e.g. Solve[{eq1, eq2} /. {C1 -> 1, C2 -> -1, k1 -> 1, k2 -> 1, u -> 3, v -> 0}, {x, y}] Aug 7, 2012 at 14:14
• ...and you've tried FullSimplify[] as well? Aug 7, 2012 at 14:14
• @J.M. seems looks better with FullSimplify[],another question is how to get rid of Slot functions in output? Aug 7, 2012 at 14:32

Without further assumptions of your used constants the solution is quite lengthy

eqs = {
u == c1 + (x - c1) (1 +
k1 ((x - c1) (x - c1) + (y - c2) (y - c2))),
v == c2 + (y - c2) (1 + k2 ((x - c1) (x - c1) + (y - c2) (y - c2)))
};
Reduce[eqs, {x, y}]

If you can provide numerical values for your constants $C_n$ and $k_n$ it is probably possible to shorten the solution.

Please have a look on your system and notice, how the number of possible (real) solutions varies when the variables change

Manipulate[
ContourPlot[{u ==
c1 + (x - c1) (1 + k1 ((x - c1) (x - c1) + (y - c2) (y - c2))),
v == c2 + (y - c2) (1 +
k2 ((x - c1) (x - c1) + (y - c2) (y - c2)))}, {x, -5,
5}, {y, -5, 5}, PlotPoints -> ControlActive[10, 40],
MaxRecursion -> ControlActive[1, 5]],
{u, -1, 1},
{v, -1, 1},
{c1, -1, 1},
{c2, -1, 1},
{k1, -1, 1},
{k2, -1, 1}
]

Addionally, lets investigate in the first solution you get from the Reduce call

k1 == 0 && x == u && k2 != 0 &&
(y == Root[(-c1^2)*c2*k2 - c2^3*k2 + 2*c1*c2*k2*u - c2*k2*u^2 - v +
(1 + c1^2*k2 + 3*c2^2*k2 - 2*c1*k2*u + k2*u^2)*#1 - 3*c2*k2*#1^2 + k2*#1^3 & ,1] ||
y == Root[(-c1^2)*c2*k2 - c2^3*k2 + 2*c1*c2*k2*u - c2*k2*u^2 - v +
(1 + c1^2*k2 + 3*c2^2*k2 - 2*c1*k2*u + k2*u^2)*#1 - 3*c2*k2*#1^2 + k2*#1^3 & ,2] ||
y == Root[(-c1^2)*c2*k2 - c2^3*k2 + 2*c1*c2*k2*u - c2*k2*u^2 - v +
(1 + c1^2*k2 + 3*c2^2*k2 - 2*c1*k2*u + k2*u^2)*#1 - 3*c2*k2*#1^2 + k2*#1^3 & ,3])

What I want to show you is that you can hack the output of Reduce directly into C++. The only thing you need is a if/else way through all the possible forms your solution can have.

Looking at the output above, you see that when k1==0 and k2!=0 your solution is that x=u and y can take 3 values. These three values are the roots of a polynomial of third order. Therefore, your three points are {x,y1}, {x,y2}, {x,y3}. Using the Manipulate and set k1 to zero shows, that this is correct:

The points where the red and the blue lines cross have indeed the same x and 3 different y.

Therefore, the only thing required for your C++ code are basic arithmetic operations and a root-solver for polynomials of third order.

• the problem is that I want to place solution in my c++ aplication and c1,c2,k1,k2 are variables. Aug 7, 2012 at 14:10
• @mrgloom, see my update. Aug 7, 2012 at 15:24
• how to format output to test each solution? (output very large and it's very complicated task to understand it) how to remove complex solutions(x,y can be just usual numbers)? how to add some known restrictions for example c1>0,c2>0? Aug 8, 2012 at 6:33