## 9500 Reputation

18 years, 138 days

## simplify/symbolic...

simplify(Ans,symbolic), though possibly a bit heavy-handed (see ?simplify,details), works here to cancel the desired terms (as well as combine the 1/x and x terms outside the Sum).

## solve symbolically...

The problem is that Maple is attempting to solve a polynomial with 365 terms. A better approach would be to solve this symbolically:
```eq := (1 + j/n)^m = val:
sol := solve(eq, j);
sol := exp(ln(val)/m)*n-n
eval(sol, [n = 365, m = 365, val=1.1]);
0.0953227
```

## limitations on immediate multiplication ...

True, but that only works if the scaling factor is a nonzero numeric.

## Re: unit step...

The easy way to handle this is to input the expression as a piecewise expression then use convert/Heaviside to convert it to an expression with unit steps (Heaviside functions). Finally use inttrans[laplace] to find its Laplace transform:
```f1 := piecewise(t <= 1, 0, t<=4, cos(Pi*t), 0):
f2 := convert(f1,Heaviside);
f2 := cos(Pi t) Heaviside(-1 + t) - cos(Pi t) Heaviside(-4 + t)
inttrans[laplace](f2, t, s);
-s*(exp(-s)+exp(-4*s))/(s^2+Pi^2)
```
To input a less-than sign (<), use the html construct &lt; (the semicolon is necessary).

## lprint and screenwidth...

There shouldn't be any problem pasting multiple lines, the real issue, I suspect, is that Maple won't accept the 2D output as input. A simple way to workaround that is to use lprint (or set interface(prettyprint=1)). The output of lprint is in 1D notation, which can be pasted into an input line. If you do not want any line breaks in the output, call interface(screenwidth=infinity) before issuing lprint. You don't normally want screenwidth = infinity because it breaks Maple's normal output (which trys to center on the screenwidth). That isn't an issue with lprint, since it prints flush left. You can write a simple procedure to temporarily reassign screenwidth and print the expression in 1D format, flush left: Lprint := proc() local width; width := interface('screenwidth' = infinity); lprint(args); interface('screenwidth' = width); NULL end proc:

## Premature evaluation...

This is a classic case of premature evaluation. In the plot3d statement, the expression Shape(x,y) is evaluated as is, that is, with the symbolic constants x and y as arguments to Shape. Because their values are themselves, Maple cannot evaluate the conditional. There are a few ways to handle this. The simplest might be to just pass the procedure Shape to plot3d: plot3d(Shape, -100..100, -100); Note that the x and y ranges are passed as ranges, not as equations. Another possibility is to modify Shape to return an unevaluated function call to Shape when x and y are not numeric: Shape := proc(x,y) if x::numeric and y::numeric then `if`(x^2 + y^2 < (Diameter/2)^2, 1, 0); else 'Shape'(args); end if; end proc: A somewhat more robust approach would also check whether Diameter is numeric.

I'm unclear on what you are asking. Do you want the unevaluated function call myproc(x,y) to display as `x whatever y'? You can more or less accomplish that by creating a `print/myproc` procedure and using a neutral operator (see ?print and ?neutral for details).
````print/myproc` := proc(a,b) a &whatever b end proc:
myproc(a,b);
a &whatever b
```

## combine/power...

Try using combine/power: y := 12/b/(b^s)*s/sin(Pi*b)^2*Pi^2; combine(y, power); 12/b^(s+1)*s/sin(Pi*b)^2*Pi^2

## Less than and greater than (angle bracke...

In html input mode, use &lt; and &gt; to input < and >, respectively. For an ampersand, use &

Just add the independent variables as arguments to a function call: y1(u1,u2), y2(u1,u2). A slightly nicer way to do this is to use the alias command (see ?alias for details): alias(y1=y1(u1,u2), y2=y2(u1,u2) ): J := (y1-y10)^2+(y2-Y20)^2+k*(u1)^2+k*(u2)^2: diff(J,u1); 2*(y1-y10)*(diff(y1, u1))+2*(y2-Y20)*(diff(y2, u1))+2*k*u1

## use frontend...

Use the frontend command; it freezes various subexpressions.
```z := a*f(x)+b*g(y)+c*x+d*y:
frontend(diff, [z,f(x)]);
a
frontend(diff, [z, x]);
c
```

## use op...

The arguments of an unevaluated function call, which is what your exp(I*theta) is, can be extracted, as an expression sequence, using the op command:
```op(exp(I*theta));
exp*theta
```
Use op with an integer to extract a particular argument:
```op(2, f(a,b,c));
b
```

## which Array...

Be aware that the Maple structure array has been largely superceded by Array. A simple procedure that does generates an Array, indexed from 0 to n and initialized with corresponding values 0 to n, is
```MyArray := proc(n::nonnegint) Array(0..n, [seq(0..n)] ) end proc:
```
If you want to start the indexing from 1, you might use a Vector, which is, more or less, a one-dimensional Array with an index that starts from unity:
```MyVector := proc(n::nonnegint) Vector([seq(0..n)]) end proc:
```

## Illegal formal parameters...

The problem is with the formal parameters. Indexed variables (the subscripted variables) don't work as formal parameters. Nor does the imaginary unit (by default `I'). It is, by the way, an appropriate place to ask.

## manifolds...

For a few ideas, possibly not relevant to your application, you might look at a package I created quite a while ago, called manifold. It's written for Maple V R4, so is quite dated and rather crude. However, the documentation isn't too bad (there is a postscript of the typeset source code). It isn't limited to three dimensions and can integrate forms over manifolds. I don't have a local copy, but it is available here.
﻿