@nm The parts that you see as (blue) 2D Input are so-called (Equation) Label References, and those are how Equation Label inputs/references appear if the GUI option is not set to render them as labels, ie. black ordinal within round brackets.

It's a flaw/bug that those cannot be directly copy&pasted properly (ie. to another worksheet, etc), even if the opened sheet is first re-executed.

@Paras31 I was curious they differ in a shorter time frame.

@Paras31 Do the contrary solutions (of this dynamical system that can exhibit chaotic behavior) start off similarly, and then diverge?

What solver is used for each, and what working precision, and what target accuracy?

@vv It can in fact still work, with Digits=15 at the top level and method=_d01akc (for oscillating integrand).

The various forced working precisions (the wrapping 'evalf[..]', digits=..., and even the evalf@Int tolerance epsilon) can be adjusted accordingly.

For example, Test_Int_fsolve_2.mw though I have not attemoted performance optimization because the target accuracy is as yet unstated.

In a severe case the integrand can also be unapplied with its own higher evalf[d] if necessary.

Note that your dsolve,numeric approach did not specify a final error tolerance, and the attained accuracy is as yet unshown. I'm not saying that it's less/more inaccurate, but I am saying that such would need to be established -- on both results -- before a thorough comparison is proper. (Some of the later entries in eqList are tougher than others...)

Note also that the OP has not (as yet) specified how much accuracy in the final results is desired.

@sija The first step is to change the undesirable
   Int( f(t), t=-4 .. t) = a
into something like,
   Int( f(t), t=-4 .. T) = a
or,
   Int( f(t), t=-4 .. x) = a
as vv had it. Otherwise it gets muddled up with name `t` serving two purposes.

Then I took rhs-lhs of the equations.

Then I used subsindets to replace the Int calls with a few options to force a fast hardware-float method and digits for the numeric quadrature, ie. when doing evalf(Int(...)).

Then I called fsolve, using unapply to turn the expressions into operator form with a forced evalf[15] to sidestep any Digits-raising by fsolve internally.

The numeric rootfinder fsolve has its own notions of accuracy and working precision, and so does evalf@Int. With one of these invoking the other then some case may be needed to balance the two (... the inner process producing at least as much accuracy --without cruft digits -- as the outer process expects, etc.)

@DJJerome1976 To be clear: for any axis you can always force your own custom tickmarks using a list of value=something items, some or all of which might be constructed conveniently using seq.

The lhs value of such items denotes where the tickmark label will appear. The rhs something denote what will appear there.

I only wrapped the something items in InertForm:-Display so that the fractions like -3*Pi/4 would not get rendered like -3/4*Pi which looks a bit awkward. That is to say, this doesn't look quite as nice:

plots:-polarplot(4, coordinateview = [0 .. 6,0 .. 2*Pi], thickness = 3,
                 axis[2]=[tickmarks=[seq(i*Pi/4=i*Pi/4-2*Pi,i=1..7),0=0],
                          gridlines=[8,subticks=2]]);

@DJJerome1976 

Download polar_ticks_rev.mw

@emendes Yes, my Answer was submitted first. (I saw it alone, right after posting it.)

However, I do not care about votes, etc. Mark as "best" whichever you feel is best.

I have now seen another thread on this site in which later Answers appear at top (even without having more votes). It's a new bug in this forum itself.

@zenterix A few ways, for fun...

Download misc_mat.mw

Duplicate Question threads on solving this polynomial system F1=eval(ode,K) may be flagged as such and deleted.

You can put your followup queries (eg. about various options to solve, other techniques, post-processing and selection amongst solutions, etc) on solving this polynomial system here.

@salim-barzani I read that other mp3.mw attachment, and the .pdf file. It was a related query on the same underlying topic.

Please put such closely related followup queries in a single Question thread (or at the very least, utilize the Branch button to automatically link them). Wholly separate duplicate threads may get flagged as such and may be deleted.

ps. I have read all the (many) questions/worksheets by previous grad students asking for help on this topic on this forum, as well as all the responses.

@salim-barzani I have deleted yet another duplicate Question thread by you on this problem.

(I discussed this with the site admin a few days ago.)

I have deleted a duplicate Question thread of this.

If you have additional details or related queries on this example/task then please add them here instead of in a separate new Question.

@C_R As stated, your middle paragraph's claim is not true. You wrote, "In Unit:-Simple Maple does not assume anything. The unit of x is left open and no dimensional check is performed unless x is assigned to a value."

Some dimensional checks are done even if x has no assigned value, with Units:-Simple loaded. Perhaps you instead meant to write that no dimensional test is done directly on x itself. That's not what you wrote.

Some dimensional checks are indeed done. That's why the OP's second example fails under Units:-Simple. The dimensional checks performed in that example -- on the terms to which unassigned x is added -- lead to a contradiction.

Download unsimpex.mw

@Thomas Richard Even with Units:-Simple loaded (via with(Units), or explicitly), there'll always be someone generating expressions with uncombined units.

Eg. using subs instead of the eval export.