User Portlet
Featured Contributor
| Discussions |
|---|
| A point outside a domain can test inside at machine precision either (1) from round-off error or (2) because machine-precisions comparisons are done with tolerance. The points `Plot3D` plugs into the function depend on the `y` range. Change it and... |
| Or use the built-in parametrization in `KnotData`: param = KnotData["Trefoil", "SpaceCurve"]; ParametricPlot3D[ (* reflect/rotate around to get like the picture *) {1, -1, 1} RotationMatrix[{{0, 1, 0}, {0, 0, 1}}] . param[t], ... |
| Your code gives two errors. The first is that `step` is undefined. If I fix that, then I get an error that tells me why I can't use `"FixedStep"`: > NDSolve::nodae: The method NDSolve`FixedStep is not currently implemented to solve... |
| Non-parallelizable code using no vectorized operations on a 16+ core machine would never utilize more than 7% CPU usage. It's hard to say more without actual code to inspect. |
| Not sure what you're after, but here's a way to get the desired behavior: test[x0_] := Thread[ToExpression[#, StandardForm, Hold] & /@ x0, Hold] /. Hold[exprs_] :> Module @@ Hold[{a = 111, b = 222, x = x0}, exprs;... |
| When I have a form I wish to keep preserved, I might replace it by its own variable — though it makes doing algebra with it difficult — or do the following, which allows for algebra to be carried out: denom = Denominator[q1] ... |
| Try adding the option to `NDSolve`, `InterpolationOrder -> All`. |
| By "runs", I mean `NDSolve[...]` evaluates to its normal output, namely, rules with interpolating functions. This means `NDSolve[...]` accepted the input and ran the solver (a few steps only, in this case). By "doesn't run", I would mean that... |
| It is worth mentioning that `PowerExpand` assumes the variables are positive (real numbers). If the variable are not always positive, then the transformations made by `PowerExpand` will be invalid. `PowerExpand` is more or less equivalent in this... |
| Nice, as usual. From my view, it's the `FullSimplify` that makes the problem feasible. One can integrate to "infinity" by just going out to 0.001. `NIntegrate` does not sample very high in this case. If you want to break your approach :) try this: ... |