I would not use Maple for such things, but paper and pencil, which is faster and easy here.

Or would just look at it via the ring Z[X]/(X^2-3), which has more mathematical sense.

Please re-consider the suggestion: I would not try to use Maple this
way, i.e. would not formulate it in an abstract way, though it is correct
in Math it may be be not a good idea for a 'computer system' (and
expecting it easily translates it).

More or less it means: the system should confirm a pattern based
on assumptions, which means that a set equipped with an operation
is a group.

There is no need that all steps inbetween are covered ...

May be you want to post your actual goal/task ?

Please re-consider the suggestion: I would not try to use Maple this
way, i.e. would not formulate it in an abstract way, though it is correct
in Math it may be be not a good idea for a 'computer system' (and
expecting it easily translates it).

More or less it means: the system should confirm a pattern based
on assumptions, which means that a set equipped with an operation
is a group.

There is no need that all steps inbetween are covered ...

May be you want to post your actual goal/task ?

How does one find that ? Besides I would not use the originally posted way ...

Anyway I find it strange:

g:=proc(n::posint:=1) return n+1; end proc;
g(k); # not assigned, not assumed to be some posint

                                  2


While the following does what I would expect

h:=proc(n::posint) return n+1; end proc;
h(k); # not assigned, not assumed to be some posint

  Error, invalid input: h expects its 1st argument, n, to be of type posint, but received k

How does one find that ? Besides I would not use the originally posted way ...

Anyway I find it strange:

g:=proc(n::posint:=1) return n+1; end proc;
g(k); # not assigned, not assumed to be some posint

                                  2


While the following does what I would expect

h:=proc(n::posint) return n+1; end proc;
h(k); # not assigned, not assumed to be some posint

  Error, invalid input: h expects its 1st argument, n, to be of type posint, but received k

There are some suggestions, which you should try.

To continue: it only makes sense, if you provide the complete setting
(as Preben said: your input is missing).

Also for that you should give some indication, *what is an expected*
result.

For the wide range of magnitudes: that is a typical source for errors
(depending on coding) like veryLarge + verySmall = veryLarge.

If you have only 2 significant decimals (if I understood it correctly)
you may have troubles anyway.

So ...

There are some suggestions, which you should try.

To continue: it only makes sense, if you provide the complete setting
(as Preben said: your input is missing).

Also for that you should give some indication, *what is an expected*
result.

For the wide range of magnitudes: that is a typical source for errors
(depending on coding) like veryLarge + verySmall = veryLarge.

If you have only 2 significant decimals (if I understood it correctly)
you may have troubles anyway.

So ...

Seen from Math the intented indexed notation is nothing but a function defined
on the integers (or parts of them or any other set).

If not needed for 'pretty appearance' (or Vectors or similar real syntax needs)
therefore I prefer to write

  x(i)

instead of x[i]: x is a function and one wants the value for the input i.

Actually this is 'the' definition of an indexed variable beyond notations in
Maple or whatever.

Nobody would write f[r] (ok, may be in MMA), hence indexed, instead of f(r)
to give the value of a function in r, it looks quite odd :-)

exp[1.0] = exp(1.0); # try to enter that in Maple

Seen from Math the intented indexed notation is nothing but a function defined
on the integers (or parts of them or any other set).

If not needed for 'pretty appearance' (or Vectors or similar real syntax needs)
therefore I prefer to write

  x(i)

instead of x[i]: x is a function and one wants the value for the input i.

Actually this is 'the' definition of an indexed variable beyond notations in
Maple or whatever.

Nobody would write f[r] (ok, may be in MMA), hence indexed, instead of f(r)
to give the value of a function in r, it looks quite odd :-)

exp[1.0] = exp(1.0); # try to enter that in Maple

Valery,

I do not want to disencourage you or even have any judgement on those
contributions (or the site you you link to).

But be just aware: if it is not done in English then it is likely to be ignored.

Simply because of language reasons.

Personally: for me it is worthless.

You may want to consider to provide at least parts in English, if you
really want to share it.

Regards,
Axel

Roughly you have a quotient of 2 polynomials (of 'high' degrees), a rational
function. That can be written as a sum of rational functions of low degree and
is called 'decomposition into partial fractions', which Maple does here.

For such one needs the roots of the denominator - hence the RootOf.

The denominator is quadratic in the variable and thus actually of degree 5, but
for those polynomials there is no explicit formula, thus Maple stays with the
notation RootOf.

Due to your assumptions Maple finds the summands are 1/(x-alpha), but to some
complicated constants and roots. Now integrating w.r.t. x gives a log (where
I used x for your Omega - shorter to type & read).

Note that the denominator does not have roots over the Reals (coeffs are all
positive and one enters with x^2, which is positive as well).

Dito for the numerator, where you can extract x^6.

It would look a bit more simple, if normaing the leading coeffs to be 1,
but the result will be the same.

Roughly you have a quotient of 2 polynomials (of 'high' degrees), a rational
function. That can be written as a sum of rational functions of low degree and
is called 'decomposition into partial fractions', which Maple does here.

For such one needs the roots of the denominator - hence the RootOf.

The denominator is quadratic in the variable and thus actually of degree 5, but
for those polynomials there is no explicit formula, thus Maple stays with the
notation RootOf.

Due to your assumptions Maple finds the summands are 1/(x-alpha), but to some
complicated constants and roots. Now integrating w.r.t. x gives a log (where
I used x for your Omega - shorter to type & read).

Note that the denominator does not have roots over the Reals (coeffs are all
positive and one enters with x^2, which is positive as well).

Dito for the numerator, where you can extract x^6.

It would look a bit more simple, if normaing the leading coeffs to be 1,
but the result will be the same.

Thank you, but finally it reduces to find and apply what others
provided, more like engineering ... but I had fun, so what :-)

Thank you, but finally it reduces to find and apply what others
provided, more like engineering ... but I had fun, so what :-)

Mine was just a cleaned-up version ...

But if I use just a function instead of exp, then the result is different:

diff(u(x,t),t)=diff(u(x,t),x,x)+ f(t);
pdsolve(%);

  `&where`(u(x,t) = _F1(x)+_F2(t), [{diff(_F1(x),`$`(x,2)) = _c[1], diff(_F2(t),t) = _c[1]+f(t)}])

I do not see the product, which occures for f = exp. Hm ?