I am trying to numerically solve a partial differential equation, where the inhomogeneous term is an integral of another function. Something like this:
NDSolve[{D[f[x, y], x] == NIntegrate[h[x,y+y2],{y2, x, y}],f[0,y] == 0}, f, {x, 0, 1}, {y,0,1}]
where h[x,y] is a well known function previously defined.
But it seems that Mathematica does not know how to evaluate the integral.
I do not use Mathematica too often, so I am sure there is a simple solution to this.
Could someone tell me what I am doing wrong?
Thanks.
It is not really clear from the question, but I had a similar problem and the solution in my case was to follow the advice from the wolfram forums to put the integral in an extra function and force real input.
So in your case this would be
integral[x_Real,y_Real] := NIntegrate[h[x,y+y2],{y2, x, y}];
NDSolve[{D[f[x, y], x] == integral[x,y], f[0,y] == 0}, f, {x, 0, 1}, {y,0,1}]
Related
I'm trying to solve for the slope with this implicit differentiation problem at x=1, but NSolve is unable to solve it. How can I get around this issue?
eqn[x_, y_] := x*Sin[y] - y*Sin[x] == 2 (*note: bound is -5<=x<=5,-5<=y<=5*)
yPrime = Solve[D[eqn[x, y[x]], x], y'[x]] /. {y[x] -> y,
y'[x] -> y'} // Simplify
{{Derivative[1][y] -> (y Cos[x] - Sin[y])/(x Cos[y] - Sin[x])}}
NSolve[eqn[x, y] /. x -> 1, y] (*this doesn't work*)
NSolve is not really the right tool for the job.
From Wolfram Documentation
If your equations involve only linear functions or polynomials, then
you can use NSolve to get numerical approximations to all the
solutions. However, when your equations involve more complicated
functions, there is in general no systematic procedure for finding all
solutions, even numerically. In such cases, you can use FindRoot to
search for solutions. You have to give FindRoot a place to start its
search.
Since your function is not really polynomial the following works :
FindRoot[eqn/.x->1,{y,-2}]
{y -> -2.7881400978783035` }
which you can plug into yprime.
Picking the starting point is not evident, however making a quick ContourPlot always works:
ContourPlot[x*Sin[y] - y*Sin[x], {x, -5, 5}, {y, -5, 5}, Contours -> {2}]
It shows that your equation is not unique for all x.
Got a simple equation but Mathematica just can't get it:
Solve[{Sin[x] == y, x + y == 5}, {x, y}]
Error: this system cannot be solved with the methods available to Solve
Am I using the right function? If not, what should I use?
Mathematica knows a lot, but it surely doesn't know everything about math. When stuffs breakdown, you can try a few different approaches:
First let's graph it:
ContourPlot[{Sin[x] == y, x + y == 5}, {x, -10, 10}, {y, -10, 10}]
It's a line intersecting a sinusoidal wave and it looks likes there is only one solution. The point is close to (5,0) so let's use the Newton method to find the root:
FindRoot[{Sin[x] == y, x + y == 5}, {x, 5}, {y, 0}]
This gives the answer {x -> 5.61756, y -> -0.617555}. You can verify it by replacing x and y in the equation with the values provided in the solution:
{Sin[x] == y, x + y == 5} /. {x -> 5.6175550052727`,y -> -0.6175550052726998`}
That gives {True,True} so the solution is correct. Interestingly, as another commenter pointed out, Wolfram Alpha gives the same solution when you type in this:
solve Sin[x]==y,x+y==5
You can access Wolfram Alpha directly from Mathematica by typing == at the beginning of a new line.
Clear["Global`*"]
Integrate[t f[x, y], {y, 0, 1}] -
t Integrate[f[x, y], {y, 0, 1}] // FullSimplify
Why doesn't M# know the result is zero?
It is not a bug. Since your f[x,y] has no definition, Mathematica can't assume anything about the integrand t f[x, y]
You can make a rule to help Mathematica as mentioned below. But without a rule, Mathematica is doing the right thing here.
This has been discussed many places before. Here are some links
https://groups.google.com/forum/#!msg/comp.soft-sys.math.mathematica/jsiYo9tRj04/rQYCy-X3SXQJ
https://mathematica.stackexchange.com/questions/5610/how-to-simplify-symbolic-integration
For example, you can add this rule:
Clear["Global`*"]
Unprotect[Integrate];
Integrate[t_Symbol*f_,dom_]:=t*Integrate[f,dom];
Protect[Integrate];
Now it will give zero
Simplify#Integrate[t f[x,y],{y,0,1}]-t Integrate[f[x,y],{y,0,1}]
(*---> 0 *)
I wanted to try to make a rule to do norm squared integrals. For example, instead of the following:
Integrate[ Conjugate[Exp[-\[Beta] Abs[x]]] Exp[-\[Beta] Abs[x]],
{x, -Infinity, Infinity}]
I tried creating a function to do so, but require the function to take a function:
Clear[complexNorm, g, x]
complexNorm[ g_[ x_ ] ] := Integrate[ Conjugate[g[x]] * g[x],
{x, -Infinity, Infinity}]
v = complexNorm[ Exp[ - \[Beta] Abs[x]]] // Trace
Mathematica doesn't have any trouble doing the first integral, but the final result of the trace when my helper function is used, shows just:
complexNorm[E^(-\[Beta] Abs[x])]
with no evaluation of the desired integral?
The syntax closely follows an example I found in http://www.mathprogramming-intro.org/download/MathProgrammingIntro.pdf [page 155], but it doesn't work for me.
The reason why your expression doesn't evaluate to what you expect is because complexNorm is expecting a pattern of the form f_[x_]. It returned what you put in because it couldn't pattern match what you gave it. If you still want to use your function, you can modify it to the following:
complexNorm[g_] := Integrate[ Conjugate[g] * g, {x, -Infinity, Infinity}]
Notice that you're just matching with anything now. Then, you just call it as complexNorm[expr]. This requires expr to have x in it somewhere though, or you'll get all kinds of funny business.
Also, can't you just use Abs[x]^2 for the norm squared? Abs[x] usually gives you a result of the form Sqrt[Conjugate[x] x].
That way you can just write:
complexNorm[g_] := Integrate[Abs[g]^2, {x, -Infinity, Infinity}]
Since you're doing quantum mechanics, you may find the following some nice syntatic sugar to use:
\[LeftAngleBracket] f_ \[RightAngleBracket] :=
Integrate[Abs[f]^2, {x, -\[Infinity], \[Infinity]}]
That way you can write your expectation values exactly as you would expect them.
I try to extract coefficient from equations (system of equations) into list (matrix). I have tried CoefficientList[poly, {var1, var2, ...}] but without success.
This simple example should explain my problem:
Eq1 = a D[U[x1, x2], {x1, 2}] + b D[V[x1, x2], {x2, 2}]
Any advice?
Edit:
Daniel's Lichtblau solution is very clear (thanks you), but what if the equation that looks like this?
Eq1 = a D[U[x1, x2], {x1, 2}] + b D[V[x1, x2], {x2, 2}] + c W[x1, x2]
A simple example can be resolved as follows:
Is there any more elegant solution? (particularly for more complex expressions)
Ps I can't understand why, but this solution gives me the correct result.
Firstly the partial derivatives are represented with Derivative, so the pattern needs to match that. Also, I don't think you want to use CoefficientList as that would accept terms where both your expressions appear. All in all, the following should work:
In[7]:= (Coefficient[Eq1, #] &) /# {Derivative[2, 0][U][x1, x2], Derivative[0, 2][V][x1, x2]}
Out[7]= {a, b}
Here (Coefficient[Eq1, #] &) is an anonymous function that finds the coefficient of the argument, and /# maps it to the list on the right.
HTH
CoefficientArrays is often useful for extracting coefficients to linear systems in some set of variables. In this case we first need to get the list of variables.
dvars = Cases[Eq1, Derivative[__][_][__], -1];
CoefficientArrays returns a result of the form {constants, coefficients}. it uses sparse arrays so I'll convert to explicit lists with Normal.
Normal[CoefficientArrays[Eq1, dvars]]
Out[672]= {0, {b, a}}
Daniel Lichtblau
Wolfram Research