This kind of manipulation comes up often enough that Alejandro Jakubi wrote a useful utility for it (and similar operations).

restart;

dividend:=proc(ex,f:=numer(ex),t:=[expand,expand])
  local n,d;
  n:=t[1](numer(ex)/f):
  d:=t[2](denom(ex)/f);
  n/d;
end proc:

e:= w^2/(w^4+2*w^2+1);

                                                      2
                                                     w
                                           e := -------------
                                                 4      2
                                                w  + 2 w  + 1

dividend(e, w^2);

                                                   1
                                             -------------
                                              2        1
                                            w  + 2 + ----
                                                        2
                                                       w

dividend(e, numer(e));

                                                   1
                                             -------------
                                              2        1
                                             w  + 2 + ----
                                                        2
                                                       w

The third argument defaults to [expand,expand] and designates the intermediate operations applied to numerator and denominator (before the final division). But it can also be useful when those intermediate operations are some other custom action.

That source definition of dividend can be put in an initialization file, or it can be assigned the name saved to a personal utility Library archive.

acer

One way (g below) involves having the original procedure be literal in the body of g.

Another way (which may not always work if your `f` is not set up to act like you intend when called with names as arguments) is to call `f` to obtain an expression, and then to `unapply` that to get your new procedure (G below).

restart;

f:=(x,y)->x+y:

g:=subs(_dummy=eval(f), x->_dummy(x,1)):

g(2);
                                                    3

G:=unapply(f(x,1),x);

                                             G := x -> x + 1

G(2);

                                                    3

f:=(x,y)->x+2*y:

g(2);

                                                    3

G(2);

                                                    3

acer

You can make theta be a parameter of the dsolve/numeric procedures.

You do not need to produce an array of values in order to do the maximization. That would be crude and likely quite inaccurate, for this or for other similar "manipulations".

You could also use the `events` option to halt or trigger when y(t)=0. I haven't bothered to do that, and kept you fsolve.

It's not very good form to do that rhs(sol[4]) sort of thing, just to pick off the proc for y(t) say. That's not critical, though.

For some reason Optimization gets confused when trying to run the dsolve/numeric procedures under evalhf. Or something like that. So I have to set UseHardwareFloats to false, to get it to succeed.

Download proyectil_1.mw

acer

ps. I deleted your duplicate post of this question.

On MS-Windows the Ctrl-m keyboard shortcut will switch from text entry mode to math entry mode, and the Ctrl-t keyboard shortcut will switch from math entry mode to text entry mode.

If you are already in math entry mode in a Worksheet then the F5 key will toggle between 1D (plaintext) Maple Notation and 2D Input.

From your attached image I suspect that what you wanted was the F5 toggle rather than the Ctrl-m/Ctrl-t toggle. It looks to me as if you were already in math entry mode (the red code prompt if in a Worksheet) but were trying to get into 2D Input/2D Math mode.

See the help-pages for more (platform specific) details on keyboard shortcuts.

acer

restart;

A:=y(x) = (1/3)*exp(x)+_C1/(exp(x))^2;

                                                         _C1
                              A := y(x) = 1/3 exp(x) + -------
                                                              2
                                                        exp(x)

simplify(A,exp);                      

                              y(x) = 1/3 exp(x) + _C1 exp(-2 x)

acer

These all seem to work (in the sense that the single backtick name-quotes are not displayed) in my 64bit Maple 2015.2 for Windows 7, including your earlier  y^`*` attempt.

Of course you might prefer to not have the asterisk raised so high, as happens when it is an exponent.

Download ast.mw

acer

The worksheet below may help you manage the display or production of zero-imaginary-components during floating-point eigen-solving.

As for your second question, well, the eigen-space associated with a particular eigenvalue may have more than one linearly independent eigenvector in its basis.

Download cmplxzero.mw

acer

Here is a quick shot at an alternate (less sophisticated) approach of weighted averaging of nearby pixels.

fiximg.mw

The timing are from a run using 64bit Maple 2016.1 for Linux on a quad-core i5. I made no attempt to parallelize (though I expect it would be easy to do by splitting one of the outer loops into pieces and using Threads:-Task (like for those escape-fractals...).

I don't do anything to correct the edge pxels (which require only a slightly different scheme).

The crude proc which applies the damage could be improved, so that the final percentage of damaged pixels could be supplied as target (and respected).

Here is a version with 35% pixels "damaged" (set to white),

And here is the fixed image.

acer

f:=rand(0..255):

[seq([seq(f(),j=1..3)], i=1..5)]; 
                  
      [[220, 141, 49], [122, 174, 7], [105, 173, 171], [136, 76, 186], [143, 128, 197]]

You could also wrap those inner lists of triples in call to ColorTools:-Color, etc. Eg,

[seq(ColorTools:-Color([seq(f(),j=1..3)]), i=1..5)];

acer

You may have made the mistake of interpreting x=y^(1/3) (outside of the RealDomain context) as being purely real-valued for y::real.

Consider which of the results in s1 below will evaluate to x=-2 when y=-8 . Notice that it is not the result of x=y^(1/3) .

restart;

s1 := [solve( {y-x^3}, x)];

   [ /     (1/3)\    /      1  (1/3)   1    (1/2)  (1/3)\   
   [{ x = y      }, { x = - - y      + - I 3      y      }, 
   [ \          /    \      2          2                /   

      /      1  (1/3)   1    (1/2)  (1/3)\ ]
     { x = - - y      - - I 3      y      }]
      \      2          2                / ]

for s in s1 do
  print( s, radnormal(eval(s, y=-8)), evalf[5](evalf(eval(s, y=-8))) );
end do:

  /     (1/3)\    /            (1/2)\                          
 { x = y      }, { x = 1 + (-3)      }, {x = 1.0000 + 1.7321 I}
  \          /    \                 /     
                     
  /      1  (1/3)   1    (1/2)  (1/3)\             
 { x = - - y      + - I 3      y      }, {x = -2}, {x = -2.0001 + 0. I}
  \      2          2                /             

  /      1  (1/3)   1    (1/2)  (1/3)\    /           (1/2)\   
 { x = - - y      - - I 3      y      }, { x = 1 - I 3      }, {x = 1.0001 - 1.7321 I}
  \      2          2                /    \                /   

But you do want x=y^(1/3) when y>0. So (outside of using RealDomain) a purely real-valued solution might be expressed as a piecewise, using the first item in s1 when y>=0 and the second item in s1 when y<0 . For example,

s2 := piecewise( y>=0, y^(1/3), y<0, -(-y)^(1/3) ):

plot( s2, y=-8..8, size=[200,200] );

Does anyone see a nice way to get :-solve to return something like that piecewise?

An alternative is to get solve to return an implicit RootOf (Maple 2015.2 used here) which evaluates to a real for real numeric y. For example,

s3 := solve( y-x^3, x, parametric, real );

            [[          /  3                     \]]
            [[x = RootOf\_Z  - y, index = real[1]/]]

s := s3[1];

             [          /  3                     \]
             [x = RootOf\_Z  - y, index = real[1]/]

evalf(eval(s,y=-8));

                           [x = -2.]

Unfortunately this is slower to plot, as it evaluates to floats internally using `evalf/RootOf` which I suspect has to go through fsolve or some numeric root-finder.

plot( eval(x,s), y=-8..8, size=[200,200] );

pr.mw

You have a sequence separated by a comma instead of an equation using `=`, for each of your eq1, eq2, eq3.

restart:

eq1 := x^2+y^2+z^2-134*x+800*y-360*z+31489=2:
eq2 := x^2+y^2+z^2-934*x+900*y-370*z+321789=2:
eq3 := x^2+y^2+z^2-614*x+1350*y-1110*z+70048=97:

sols:=[solve({eq1, eq2, eq3}, {x, y, z}, explicit, allsolutions)]:

nops(sols);
    
                                                             2

for s in sols do simplify(map(rhs-lhs,eval([eq1, eq2, eq3],s))); end do;

                                                         [0, 0, 0]

                                                         [0, 0, 0]

acer

Indeed, in Maple 2016 the examples in vv's Answer work, due to enhanced resolution by Explore of assigned names. (See the section "Name resolution" here.)

In Maple 2015.2 I could get the following modified examples to work (by working around the special-evaluation rules of Explore on its first argument).

restart;
N  := 2:
F  := add(P||k * x^k, k=0..N):
G := [seq(P||k=-1.0 .. 1.0, k=0..N)]:
eval('Explore'('plot'(F, x=0..1), parameters=G));

and,

restart;
F := a*x:
eval('Explore'('plot'(F, x=0..1), parameters = [a=0.0..1.0]));

There seemed to be some combination of tags like <Font> ... <TextField> ... </Font> ... </Text-field> which may be closed out of order. Or similar things like that with Font tags. After trying to sort those out I get this.

Why1.mw

Does that contain most or all of what you expected? There appear to be one or two places where assignment statements inlined in text are unexpected, upon re-execution with the !!! from the main menubar. Hopefully you could cut and paste to sort those out.

acer

It works for me using 64bit Maple 2016.1 on 64bit Windows 7 Pro.

But I had to define n, which I did using a new integer[4] local. Otherwise it still compiled but did not run. It also worked if I assigned a suitable value to global n.

For a concrete example it worked whether I used the autocompile step or the explictly compiled proc which I assigned to name cstep and ran.

Have you tried it with n declared local and assigned? And without the option autocompile?

In Maple 2016 Compiler:-Compile will used the external llvm compiler that is bundled with Maple. That compiles to an object in memory and runs it directly on the stack, I believe. If it fails to compile for you (but does for others) then you might get joy by passing the option inmem=false to Compiler:-Compile. although that might require you to have a working MSVC++ like for Maple 17(?) and older. That would revert to the older mechanism of compiling generated C code to temporary object file and dll. I have several of the "free" MSVC++/SDK for 64bit Windows installed, which is how my older Maple's also use Compile. For me it works with or without the inmem=false option.

acer

You can supply a forcing view when using the draw command. (I am using Maple 2016, since that is listed as the product in question here.)

But if you don't want to figure out the pertinent ranges then it might just be easier to get rid of the VIEW substructure.

Download drawwithview.mw

acer