## 7767 Reputation

14 years, 215 days

## Use fsolve...

I'll assume that you are looking for a numeric, rather than symbolic, solution (good luck with the latter). The following works: y := sin(x)/x: dy := diff(y,x): sol := fsolve(dy,{x},0..10); # the third parameter restricts the domain sol := {x = 4.493409458} eval(dy,sol); # check the result 1*10^(-11) eval(y,sol); # evaluate the expression -0.2172336282

## Extracting derivatives---one approach...

Here's one way, probably not the best.
```tmp := Int(D[3](F)(x,t,y(x,t),diff(y(x,t),x),diff(diff(y(x,t),t),x))(diff(yv(x,t),t,x)),t):
tmp2 := convert(tmp,D):
indets(tmp2, typefunc(anything, typefunc(identical(yv),specindex(posint,D)))):
convert(%,diff);
{diff(yv(x, t), x, t)}
```

## collecting symbolic powers...

Your observation is correct, collect works with power of integers, not symbolics. For the simple example you gave, factor will do nicely. However, consider

`poly := a*x^b + x^b + a*x^(b+1) + c*x^(b+1);`

The collect command can also handle unevaluated function calls, so one approach is to convert the monomial terms to function calls, collect, then convert back:

```subsindets(poly, identical(x)^anything, () -> f(op(args)));

a*f(x, b) + f(x, b) + a*f(x, b + 1) + c*f(x, b + 1)

collect(%,f);

(a + 1)*f(x, b) + (a + c)*f(x, b + 1)

eval(%, f=`^`);

(a + 1)*x^b + (a + c)*x^(b+1)```

## Drawing Gabriel's Horn...

An easy way to express the surface is in cylindrical coordinates. Thus,
```plot3d(1/z, theta=0..2*Pi, z = 1..20, coords=cylindrical);
```
should do the trick.

## 1x1 matrix is not a scalar...

It cannot. A 1x1 matrix (or Matrix) is not a scalar. Consider the product of three vectors/covectors: (mx1)(1xn)(nx1). You want to rearrange this as (1xn)(nx1)(mx1). However, if that were done, then associativity wouldn't hold, that is, (nx1)(mx1) is undefined.

## LinearAlgebra:-Equal...

Use LinearAlgebra:-Equal to test equality of Matrices (with expressions as elements). For more general testing, you can use verify (with appropriate verification argument).
```with(LinearAlgebra):
A := <<1,2>>:
B := Copy(A):
Equal(A,B);
true

A := <<1,2>>:
B := <<1.001, 1.99>>:
verify(A,B,'Matrix'(float(5,digits=3)));
true

verify(A,B,'Matrix'(float(5,digits=4)));
false
```

## e is just a symbol...

Use exp(x) for e^x

## painless...

Yes. Explain what it is you want to do.

## anonymous procedure call, etc....

Your comments are basically correct. The statement (x -> x.x)(procname(x,n/2)) passes the argument procname(x,n/2) to the anonymous procedure x -> x.x. It is equivalent to doing tmp := procname(x,n/2); tmp.tmp but avoids the local variable tmp. The reason that . was used rather than * is to allow this to work with Matrices: Pow(<<1|2>,<3|4>>,-2); [11/2 -5/2] [ ] [-15/4 7/4 ]

## Diff Operators...

Here's one approach:
```> M := Matrix([[x,0],[0,y],[y,0],[0,x]]);
[x    0]
[      ]
[0    y]
M := [      ]
[y    0]
[      ]
[0    x]

> DM := map(v -> `if`(v=0,0,rcurry(diff,v)),M);
[() -> diff(args, x)             0         ]
[                                          ]
[         0             () -> diff(args, y)]
DM := [                                          ]
[() -> diff(args, y)             0         ]
[                                          ]
[         0             () -> diff(args, x)]

> map(apply,DM,x^2+y);
[2 x     0 ]
[          ]
[ 0      1 ]
[          ]
[ 1      0 ]
[          ]
[ 0     2 x]
```
This doesn't solve the problem of applying it to a Matrix.

## unapply...

As Roman suggests, create a procedure rather than a polynomial. However, if you have already created the polynomial, you then need to convert it to a procedure. The procedure unapply is useful here.
```P := a*x1^2 + 3*x2^2 + b:
f := unapply(P, [x1,x2]):
f(z1,z2);
a*z1^2+3*z2^2+b
```
Note that your example use of eval is incorrect. Proper usage is eval(P, [x=1,y=2]).

## use linalg[norm]...

```> LengthU := norm(u,2);
2
```

## MakeUnique...

Unlike many other elements, Maple does not consider rtables (the low-level struture that includes Vectors) equal even if they have the same elements. The LinearAlgebra command Equal can be used to determine element by element (or just structure) equality of two Vectors. One way to do what you want is to convert the set to a list, then use ListTools:MakeUnique, passing LinearAlgebra:-Equal as the optional comparison procedure. Thus lst := convert(s, list): lst := ListTools:-MakeUnique(lst,1,Equal): s := convert(lst, set); An interesting observation is that if you had done s := {UnitVector(1,2), UnitVector(1,2)}: s would have been assigned a singleton. The reason for that is subtle, Maple applies its set simplification to the input before UnitVector is called, so at that point the set consistents of two identical function calls. This simplification can result in incorrect results if the functions return different values.

## Change x to t...

Try spacecurve([2*t,0,0],t=0..1)

## inttrans and heaviside......

You must have used the command with(inttrans) somewhere, otherwise Maple wouldn't have plotted the first y1. However, I have no problem with the second. What version of Maple are you using? Note that y1 is expressed in terms of the Heaviside function, which may have caused problems for some versions of Maple (my memory is fuzzy).
 First 97 98 99 100 101 Page 99 of 101
﻿