simplify(abs(x)-sqrt(x^2))  assuming x::real;

                                    0

This issue differs from the previous in that the right-hand side of the equation is much smaller. Therefore, the possibility appeared to estimate the  number of solutions. It turned out that solutions more than 100000000. Furthermore, among the solutions, we find the solution with minimum norm.

Finding the number of solutions:

restart;

eq:=30*a+75*b+110*c+85*d+255*e+160*f+15*g+12*h+120*i=8000:

isolve(eq);

ineq:=5*_Z1+10*_Z2+25*_Z3+35*_Z4+25*_Z5+40*_Z6+5*_Z7+10*_Z8<640;

L:=coeffs(lhs(ineq));

k:=0:

for _Z1 to (640-`+`(L[2..8]))/5 do

for _Z2 to (640-5*_Z1-`+`(L[3..8]))/10 do

for _Z3 to (640-5*_Z1-10*_Z2-`+`(L[4..8]))/25 do

for _Z4 to (640-5*_Z1-10*_Z2-25*_Z3-`+`(L[5..8]))/35 do

for _Z5 to (640-5*_Z1-10*_Z2-25*_Z3-35*_Z4-`+`(L[6..8]))/25 do

for _Z6 to (640-5*_Z1-10*_Z2-25*_Z3-35*_Z4-25*_Z5-`+`(L[7..8]))/40 do

for _Z7 to (640-5*_Z1-10*_Z2-25*_Z3-35*_Z4-25*_Z5-40*_Z6-L[8])/5 do

for _Z8 to (640-5*_Z1-10*_Z2-25*_Z3-35*_Z4-25*_Z5-40*_Z6-5*_Z7)/10 do

if ineq then k:=k+1 fi;

od: od: od: od: od: od: od: od:

k;  # The  number of solutions for positive integer parameters  _Z1, _Z2, ..., _Z8

Next we find a solution with minimum norm. To do this, first we find the optimal solution in two ways without regard integer, and then varying the closest integer solutions solves the problem:

restart;

eq:=30*a+75*b+110*c+85*d+255*e+160*f+15*g+12*h+120*i=8000:

F:=a^2+b^2+c^2+d^2+e^2+f^2+g^2+h^2+i^2:

Optimization[QPSolve](F,{eq}, assume=nonnegative);

extrema(F, {eq}, indets(F),'s'): evalf(convert(op(s),list));

map(t->[round(rhs(t)-4),round(rhs(t)+4)], %);

Dist:=infinity:

for a from 1 to 6 do

for b from 1 to 9 do

for c from 3 to 11 do

for d from 1 to 9 do

for e from 12 to 20 do

for f from 6 to 14 do

for g from 1 to 5 do

for h from 1 to 5 do

for i from 3 to 11 do

if eq then dist:=F;

if dist<Dist then Dist:=dist; Sol:=[a,b,c,d,e,f,g,h,i]  fi; fi;

od: od: od: od: od: od: od: od: od:

['a'=Sol[1],'b'=Sol[2],'c'=Sol[3],'d'=Sol[4],'e'=Sol[5],'f'=Sol[6],'g'=Sol[7],'h'=Sol[8],'i'=Sol[9]];  # The solution with minimal norm

Edit. Comments on the first  code was corrected. In fact, this code finds not all solutions but only part of the solutions for positive values of parameters. The total number solutions is  more than 106141495 solutions.

Example:

plot([x,x^2,x^3], x=-1..1, thickness=2, legend=[x,x^2,x^3]);

for your way:

unapply(diff(f(x), x), x);

                  x->2*x

Of course, the use of the operator  D  is more preferably.

M:=8:  K:=6:  K1:=K-2*K2:

Sum(M!/(M-K1-K2)! * K!/(K1! * K2)! * 1/M^K * 1/2^K2, K2=0..K/2);

value(%);

I do not understand why you need something to simplify. You can easily to define  this matrix as done below and calculate its determinant with any precision for any  k  and  alpha :

Example:

L:=[J,Y,`I`,K]:

A:=Matrix(4,(i,j)->`if`(i=1 or i=2,cat(Bessel,L[j])(i+1,2*k*sqrt(alpha)/(alpha-1)),cat(Bessel,L[j])(i+1,2*k/(alpha-1)))):

F:=unapply(Matrix(4,{seq(seq(`if`(j=3 and (i=2 or i=4),(i,j)=-A[i,j], (i,j)=A[i,j]),j=1..4),i=1..4)}), k,alpha):

F(k,alpha);

evalf[20](LinearAlgebra[Determinant](F(2,3)));

 Edit. The code and the example was corrected (at first I missed minus signs)

I corrected your syntax as I understood it:

f := x->piecewise(abs(x)<1,1-x,0);

U := (x,t)->2/3*f(x+t)+1/3*f(x-2*t)+1/(3*Pi)*sin(Pi*(x+t))+1/(3*Pi)*sin(Pi*(x-2*t));

plot3d(U(x,t), x=0..3, t=0..3, axes=normal, numpoints=10000);

The original problem has an obvious meaning, if one or both parameters  H1  and  H2  are 0 or negative, but the proposed solution does not work for these cases. Here is the solution in the form of a procedure that works for all cases. The procedure is very simple, it is based on direct calculation of the volume by a single integration over the cross sectional area (each a cross-section - this is the usual circle segment).

restart;

V:=proc(R,H1,H2)

local r, H;

if is(H1^2+H2^2>R^2) then error "Should be H1^2+H2^2<=R^2" fi;

r:=int((R^2-x^2)*arccos(H1/sqrt(R^2-x^2))-H1*sqrt(R^2-x^2-H1^2), x=H2..sqrt(R^2-H1^2));

if is(H1>=0) then return simplify(r) else

H:=R-sqrt(R^2-H1^2);

simplify(r+Pi*H^2*(R-H/3)) fi;

end proc:

Examples of use:

V(1,1/2,1/2);

 evalf(%);

V(1,0,1/2);

V(1,1/2,0); 

V(1,-1/2,1/2);

 evalf(%);

V(1,1/2,-1/2);

 evalf(%); 

V(1,0,0); 

V(1,-1/2,-1/2);

 evalf(%);

V(1,-1/sqrt(2),-1/sqrt(2));

 evalf(%);

Here are solutions the same examples by Rouben's formula:

Vwedge :=(R,a,b)->-( (1/3)*Pi*R^3-(1/6)*Pi*(2*R+a)*(R-a)^2-(1/6)*Pi*(2*R+b)*(R-b)^2-(1/3)*a*(3*R^2-a^2)*arcsin(b/sqrt(R^2-a^2))-(1/3)*b*(3*R^2-b^2)*arcsin(a/sqrt(R^2-b^2))-(2/3)*a*b*sqrt(R^2-a^2-b^2)+(1/3)*R^3*arctan((R^2+R*b-a^2)/(sqrt(R^2-a^2-b^2)*a))-(1/3)*R^3*arctan((R^2-R*b-a^2)/(sqrt(R^2-a^2-b^2)*a))):

Vwedge(1,1/2,1/2);

 evalf(%);

Vwedge(1,0,1/2);

Vwedge(1,1/2,0);

Vwedge(1,-1/2,1/2);

 evalf(%);

Vwedge(1,1/2,-1/2);

 evalf(%);

Vwedge(1,0,0);

Vwedge(1,-1/2,-1/2);

 evalf(%);

Vwedge(1,-1/sqrt(2),-1/sqrt(2));

Edit.  The procedure  V  worked incorrectly if  H1<0 . So the procedure and all the examples was corrected. Now all right. The number of examples was increased. 

plot3d([sin(u)*(7+cos(u/3-2*v)+2*cos(u/3+v)), cos(u)*(7+cos(u/3-2*v)+2*cos(u/3+v)),

sin(u/3-2*v)+2*sin(u/3+v)], u=-Pi..Pi, v=-Pi..Pi,  axes=normal, orientation=[30,30], lightmodel=light4);

Edited: the extra commas was removed. 

To the points of not too often flashed for every point allotted 10 frames:

L := [seq([i, i^2]$10, i = 1 .. 4)];

Frames := seq(plots[display](plots[pointplot](L[2 .. i], style = point, symbol = solidcircle, symbolsize = 12, color = red)), i = 1 .. nops(L)):

plots[display](Frames, insequence = true, view = [0 .. 4.5, 0 .. 16]);

This will be true if we assume that all constants are positive:

temp := (1/2)*(a*r*t-b*p)*sqrt(p+v*sqrt(a*r))*sqrt(b)/(sqrt(a*b*r*t)*sqrt(a*r*t*(p+v*sqrt(a*r))))+(1/2)*(a*r*v*t-v*b*p+p*t*sqrt(a*r)-b*v^2*sqrt(a*r))*sqrt(b)/(sqrt(a*b*r*t*(p+v*sqrt(a*r)))*sqrt(t*(p+v*sqrt(a*r))))+(1/2)*b*(p+v*sqrt(a*r))/(a*r*t);

normal(expand(rationalize(simplify(temp))))  assuming positive;

                                               1

You can decide in short, if you already know the answer:

is(temp = 1)  assuming positive;

                                             true

I think that in order to achieve complete clarity in finding all real roots of the equation  a=1-(1+x)*exp(-x)  for any real  a  is useful to make the simplest study of the function defined of the right-hand side of the equation:

f:=x->1-(1+x)*exp(-x):

g:=diff(f(x), x);

map(solve, [g=0, g<0, g>0]);

minimize(f(x), x=-infinity..0, location),  maximize(f(x), x=-infinity..0, location);

minimize(f(x), x=0..infinity, location),  maximize(f(x), x=0..infinity, location);

plot([f(x), 1], x=-1.5..5, thickness=[2,1], linestyle=[1,2], scaling=constrained);

We can see (and the plot confirms) that the function  f  is strictly decreasing in the domain  RealRange(-infinity,0) and takes all the values from  RealRange(0,infinity)  and  f  is strictly increasing in the domain  RealRange(0,infinity) and takes all the values from  RealRange(0, Open(1)) . 

On the basis of this information written procedure  SS , which finds all the real roots of the equation with a given accuracy (the numbers of digits):

restart;

SS:=proc(a::realcons, n::posint:=10)

local eq, b;

Digits:=n;

b:=evalf(a);

eq:=a=1-(1+x)*exp(-x);

if b<0 then return `No real solutions` elif

b=0. then return x=0 elif

b>0 and b<1 then return x[1]=fsolve(eq, x=-infinity..0), x[2]=fsolve(eq, x=0..infinity) else return x=fsolve(eq, x=-infinity..0) fi;

end proc:

Examples of use:

SS(-2);  SS(0);  SS(1/Pi);  SS(1);  SS(3, 20);

This system can be solved instantly (and we obtain all solutions) by  solve  command:

restart;

eq[1]:= 0.223569*c_1+2.35589*c_2*c_1^2+0.002356*c_1*c_2^2:

eq[2]:= 1.277899*c_1*c_3-2.350023*c_2*c_3^2+7.5856*c_3*c_2^2:

eq[3]:= 3.225989*c_1^2-2.35589*c_3*c_1^2-7.28356*c_3*c_2^3:

solve({eq[1], eq[2], eq[3]}, {c_1, c_2, c_3});

Your example can be easily generalized to any natural number, if you use the binary number system. In it  any number  S such that  1<= S <2^n  can be recorded as the sequence of no more than  n  of  "0"  and  "1" .

The first procedure for a given number  S  returns the list of the number of dollars in each bag that your condition is true. The second procedure returns the corresponding partition for any number.

MinBags:=proc(S)

[seq(2^n, n=0..ilog[2](S))];

end proc:

Parts:=proc(s)

local L;

L:=convert(s, base, 2);

convert(s,symbol)=convert([seq(`if`(L[i]<>0,convert(L[i]*2^(i-1),symbol),NULL), i=1..nops(L))], `+`);

end proc:

Examples.

Your example:

MinBags(15);

for n from 1 to 15 do

Parts(n);

od;

Another example:

MinBags(137);

for n from 100 to 110 do

Parts(n);

od;

You can easily solve the problem by converting the output into the list, and reversing it:

A:=<1,1,1,1; 1,2,3,4; 4,3,2,1>;

LinearAlgebra[NullSpace](A);

ListTools[Reverse](convert(%, list));