Advanced Search

Carl Love

Carl Love

28035 Reputation

25 Badges

12 years, 317 days
Himself
Wayland, Massachusetts, United States
Contact Carl Love
My name was formerly Carl Devore.

MaplePrimes Activity


These are answers submitted by Carl Love

Shift the z-coord of the base center...

Carl Love 28035
July 08 2015
0 3

How about shifting the z-coordinates of the centers of the base circles?

p1:= plottools:-cylinder([1, 1, 1], 1, 1):
p2:= plottools:-cylinder([1, 1, 2], 2, 3):
p3:= plottools:-cylinder([1, 1, 5], 1, 4):

plots:-display([p1,p2,p3]);

Matrices over finite fields...

Carl Love 28035
July 08 2015
1 5

Here's an example of your 1, 2, and 3. There are many ways for 2 and 3. Pay special attention to the way that prime-power fields are created in Maple because it's a little unusual.

restart:
#0. Create the matrix
p:= Randprime(3,x) mod 2;
alias(x= RootOf(p,x)):
M:= Matrix(5,7, ()-> randpoly(x, degree= 3));

#1. Get the rank.
Gausselim(M, 'rank') mod 2:
rank;
     5


#2. Row sum squared
V:= Vector(op([1,1], M), i-> expand(add(y, y= M[i,..])^2));

#3. Dividing by row sum squared
Matrix(op(1,M), (i,j)-> M[i,j]/V[i]);

 

sign, primpart, and content...

Carl Love 28035
July 07 2015
1 2

See the commands ?sign, ?primpart, and ?content. Using those, here's a short procedure for it:

p:=x^2*y-2*y*z+3*x^2+2*y-z:

RepeatPositiveTerms:= (P::polynom(integer))->
     [seq(`if`(sign(t)=1, primpart(t) $ content(t), [][]), t= [op(expand(P))])]
:

RepeatPositiveTerms(p);

     [x^2*y, x^2, x^2, x^2, y, y]

 

elementwise functions...

Carl Love 28035
July 07 2015
1 0

Any function can be made to map over a list by appending ~ to its name:

abs~(L);
signum~(L);

Or, getting a bit fancier, there's

(abs~, signum~)(L);

 

More equations than unknown functions...

Carl Love 28035
July 07 2015
0 1

Your system is overspecified: You have three equations, but only two unknown functions. This can't be solved.

plot3d...

Carl Love 28035
July 06 2015
0 1

In general, it is a bad idea to use D and gamma as variable names because they have predefined meanings in Maple; however, your usage of them here causes no problem.

The purpose of the macro below is to simplify the typing of the function. If you don't like it, you can just as well continue to use BesselJ and HermiteH.

macro(B= BesselJ, H= HermiteH):
F:= (Pi*B(1,x)*H(0,x) + 2*B(0,x) - Pi*B(0,x)*B(1,x)*H(0,x)) *
        exp(-x^2*D*t/alpha)*B(0,x/chi)/B(1,x)^2 -
        M[0]*T[2]*gamma*exp(-T[g]/T[0]*(t-delta));
params:=
      [M[0]= 8, g= 9.8, gamma= 1.17, r= 1.15, T[g]= 1.11111,
      T[0]= 3.666667, t= 5e-9, delta= 0.002, x= 3.478505,
      alpha= 5.36, k= 1.2, r= 1.15, D= 7.46];

plot3d([chi, eval(F, params), T[2]], chi= 0.22..0.25, T[2]= 300..900, grid= [4,4]);

The purpose of grid= [4,4] is to restrict chi and T[2] to the four discrete values that you specified. You could just as well omit it and then a 50x50 grid would be used.

pdsolve...

Carl Love 28035
July 06 2015
0 0

The general command to solve it is pdsolve:

pdsolve(diff(c(x,t),t)=diff(c(x,t),x,x)-diff(c(x,t),x)-c(x,t), c(x,t));

But unless you specify the initial and boundary conditions in the command, the solution returned is somewhat trivial. (Perhaps "trivial" is not the right word: maybe "overly general" better describes it.) If you are having trouble putting the intial and boundary conditions into the form that Maple wants, let me know.

fnormal...

Carl Love 28035
July 06 2015
1 5

Use the command fnormal (see ?fnormal).

Why is there a solution?...

Carl Love 28035
July 06 2015
0 4

What makes you think that a solution exists within the ranges that you give?

You should try changing those three parameters gradually and one at a time to see where it stops giving you a solution. Then go one step back to where you had solution. Check if any variable is close to one boundary of its range. 

I did the above for your system. I was able to push t_prof and t_r all the way to 0.16 and t_w to 0.12. At this point M = 0.400056799031096, which is very close to its lower limit of 0.4. If I lower the lower limit of M, I can raise t_w.

The trace command (also known as debug)...

Carl Love 28035
July 05 2015
1 1

 

restart:

 

The command debug is synonymous with trace. I'll try to get into the habit of calling it trace because that it a better description of what it does.

 

The goal of using trace in this worksheet is to see when procedures from package Groebner are called, and if they are called, where are they called from, what are the arguments, and what are the return values.

 

First, I will use it on this procedure that calls eliminate.

CoeffsOfLinComb:= proc(

     L::list(polynom),

     V::set(name):= indets(L, And(name, Not(constant))),

     $

)

local

     c, k, C:= {c[k] $ k= 1..nops(L)},

     S:= eliminate({coeffs(expand(`+`((C*~L)[])), V)}, C),

     F:= indets(rhs~(S[1]), name) intersect C=~ 1

;

     eval([C[]], eval(S[1],F) union F)

end proc:

 

PolyLinearCombo:= proc(

     F::list(polynom),

     f::polynom,

     V::set(name):= indets([F,f], And(name, Not(constant))),

     $

)

local C:= CoeffsOfLinComb([f, F[]], V);

     if f=0 then  return (true, [0$nops(F)])  end if;

     if C[1]=0 then  (false, [])  else  (true, -C[2..] /~ C[1])  end if

end proc:

 

F:= [a*A1 + b*A3, c*A2+d*A3]:
f:= e*A1+h*A2:

N:= {e*b*c + a*h*d}:  W:= [a,c]:

{a*d*h+b*c*e}

[a, c]

trace(Groebner);

[Groebner:-BasisTable, Groebner:-OutputBasis, [[MatrixOrder:-ModuleApply], ShortMonomialOrders:-VerifyOrder, [LeadingTermProc:-UserOrder, LeadingTermProc:-WalkOrder, LeadingTermProc:-ModuleApply], [NextMonomialProc:-ModuleApply], ShortMonomialOrders:-EliminationStructure, ShortMonomialOrders:-IsElimOrder, ShortMonomialOrders:-SimilarOrders, ShortMonomialOrders:-ProjectOrder, ShortMonomialOrders:-FGBOrder], Groebner:-MonomialOrder, [[gbasis:-init, gbasis:-compute, gbasis:-walk_compute, gbasis:-ModuleApply, gbasis:-gsolve_init, gbasis:-gsolve], Buchberger:-sort_list_by_lm, Buchberger:-normalize_sign, Buchberger:-minimize_gb, Buchberger:-inter_reduce_gb, Buchberger:-inter_reduce, Buchberger:-InterReduce, Buchberger:-GroebnerBasis, Buchberger:-NormalForm, Buchberger:-GSolve], [F4:-NormalForm, F4:-GroebnerBasis], Groebner:-RewriteProc, [FGLM:-ConvertGB, FGLM:-ModuleApply], [Walk:-ConvertGB, Walk:-ModuleApply], Groebner:-LeadingTerm, Groebner:-LeadingMonomial, Groebner:-LeadingCoefficient, Groebner:-TrailingTerm, Groebner:-WeightedDegree, Groebner:-InitialForm, Groebner:-Support, Groebner:-Homogenize, Groebner:-MatrixOrder, Groebner:-SuggestVariableOrder, Groebner:-RememberBasis, [SubstituteRootOfs:-substitute_rootofs, SubstituteRootOfs:-collect_rootof_powers, SubstituteRootOfs:-ModuleApply], Groebner:-Basis, Groebner:-InterReduce, Groebner:-Reduce, Groebner:-NormalForm, Groebner:-SPolynomial, Groebner:-Solve, Groebner:-RationalUnivariateRepresentation, Groebner:-UnivariatePolynomial, Groebner:-ModuleGB, Groebner:-IsProper, Groebner:-IsZeroDimensional, Groebner:-MaximalIndependentSet, Groebner:-HilbertDimension, [HilbertSeries:-ModuleApply], Groebner:-HilbertPolynomial, Groebner:-TestOrder, [MultivariateCyclicVector:-ModuleApply], Groebner:-NormalSet, Groebner:-MultiplicationMatrix, [ToricIdealBasis:-ModuleApply], Groebner:-IsBasis, Groebner:-fglm_algo, Groebner:-gbasis, Groebner:-gsolve, Groebner:-hilbertdim, Groebner:-hilbertpoly, Groebner:-hilbertseries, Groebner:-is_finite, Groebner:-is_solvable, Groebner:-leadcoeff, Groebner:-leadmon, Groebner:-leadterm, Groebner:-normalf, Groebner:-pretend_gbasis, Groebner:-reduce, Groebner:-inter_reduce, Groebner:-spoly, Groebner:-termorder, Groebner:-testorder, Groebner:-univpoly, Groebner:-SetBasis, Groebner:-MulMatrix, Groebner:-init, Groebner:-_pexports]

R:= PolyLinearCombo(F, f, {A||(1..3)}):

The absence of any output shows that none of the procedures in the above list are called.

R;

false, []

The procedure below uses simplify with side relations in addition to eliminate. We will see that the simplify does use Groebner procedures.

ExtPolyLinearCombo:= proc(
     F::list(polynom),
     f::polynom,
     V::set(name),
     Null::set(polynom):= {},
     NotNull::set(polynom):= {}
)
local
     c, k, C:= {c[k] $ k= 1..nops(F)},
     S:= eliminate(simplify({coeffs(expand(`+`((C*~F)[]) - f), V)}, Null), C)
;
     if
          lhs~(S[1]) <> C or
          not simplify(S[2], Null) subset {0}
          # or not andmap(s-> is(denom(rhs(s)) <> 0), S[1])
          #      assuming (NotNull <>~ 0)[], (Null =~ 0)[]
     then
          return false, []
     end if;
     
     true, eval([C[]], S[1])
end proc:

 

Note that I end the command below with a colon. This substantially reduces the amount of output. In this case, I am only interested in the entry and exit points.

R:= ExtPolyLinearCombo(F, f, {A||(1..3)}, N, W):

{--> enter Groebner:-SuggestVariableOrder, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, [_t[1], _t[2], _t[3], _t[4], _t[5], _t[6]]

<-- exit Groebner:-SuggestVariableOrder (now in simplify/siderels:-simplify/siderels) = _t[6], _t[5], _t[4], _t[3], _t[2], _t[1]}
{--> enter Groebner:-Basis, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), characteristic = 0, output = basislm
{--> enter Groebner:-BasisTable, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, 0
<-- exit Groebner:-BasisTable (now in Groebner:-Basis) = table( [ ] )}
{--> enter ShortMonomialOrders:-SimilarOrders, args = plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), []
<-- exit ShortMonomialOrders:-SimilarOrders (now in Groebner:-Basis) = []}
{--> enter Groebner:-Basis, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, itord, variables = {_t[1], _t[2], _t[3], _t[4], _t[5], _t[6]}, characteristic = 0, output = basislm
value remembered (in Groebner:-Basis): Groebner:-BasisTable({_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, 0) -> table( [ ] )
{--> enter Groebner:-SuggestVariableOrder, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]], {_t[1], _t[2], _t[3], _t[4], _t[5], _t[6]}
<-- exit Groebner:-SuggestVariableOrder (now in Groebner:-Basis) = _t[6], _t[5], _t[4], _t[3], _t[2], _t[1]}
{--> enter ShortMonomialOrders:-FGBOrder, args = tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])
<-- exit ShortMonomialOrders:-FGBOrder (now in Groebner:-Basis) = [[_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]]]}
{--> enter SubstituteRootOfs:-ModuleApply, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]
<-- exit SubstituteRootOfs:-ModuleApply (now in Groebner:-Basis) = {}, {}, [], {}}
{--> enter Groebner:-LeadingTerm, args = _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5], lexdeg([_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]], [])
{--> enter LeadingTermProc:-ModuleApply, args = lexdeg([_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]], [])
<-- exit LeadingTermProc:-ModuleApply (now in Groebner:-LeadingTerm) = proc (f) lc, lm := f, 1; for i to N do lc := lcoeff(lc, vars[i], 'lmt'); lm := lm*lmt end do; lc, lm end proc}
<-- exit Groebner:-LeadingTerm (now in fgbrs:-fgb_gbasis) = 1, _t[2]*_t[3]*_t[5]}
{--> enter Groebner:-RememberBasis, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]], [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), characteristic = 0, skiptypecheck = true
value remembered (in Groebner:-RememberBasis): Groebner:-BasisTable({_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, 0) -> table( [( tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]) ) = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]] ] )
<-- exit Groebner:-RememberBasis (now in Groebner:-Basis) = }
{--> enter Groebner:-OutputBasis, args = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), true
<-- exit Groebner:-OutputBasis (now in Groebner:-Basis) = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
<-- exit Groebner:-Basis (now in Groebner:-Basis) = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
{--> enter Groebner:-OutputBasis, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), true
{--> enter LeadingTermProc:-ModuleApply, args = plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])
<-- exit LeadingTermProc:-ModuleApply (now in Groebner:-OutputBasis) = proc (f) lcoeff(f, vars, 'lm'), lm end proc}
<-- exit Groebner:-OutputBasis (now in Groebner:-Basis) = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
{--> enter Groebner:-OutputBasis, args = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), true
<-- exit Groebner:-OutputBasis (now in Groebner:-Basis) = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
<-- exit Groebner:-Basis (now in simplify/siderels:-simplify/siderels) = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
{--> enter Groebner:-NormalForm, args = [_t[1]*c[1]-_t[5]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), characteristic = 0
{--> enter Groebner:-Reduce, args = [_t[1]*c[1]-_t[5]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), s, FAIL, characteristic = 0, normalize = false
{--> enter SubstituteRootOfs:-ModuleApply, args = [[_t[1]*c[1]-_t[5]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]]
<-- exit SubstituteRootOfs:-ModuleApply (now in Groebner:-Reduce) = {}, {}, [], {}}
{--> enter F4:-NormalForm, args = [_t[1]*c[1]-_t[5]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), 0
value remembered (in initf4): LeadingTermProc:-ModuleApply(plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])) -> proc (f) lcoeff(f, vars, 'lm'), lm end proc
{--> enter ShortMonomialOrders:-VerifyOrder, args = plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])
<-- exit ShortMonomialOrders:-VerifyOrder (now in initf4) = true}
<-- exit F4:-NormalForm (now in Groebner:-Reduce) = [_t[1]*c[1]-_t[5]]}
<-- exit Groebner:-Reduce (now in Groebner:-NormalForm) = [_t[1]*c[1]-_t[5]]}
<-- exit Groebner:-NormalForm (now in simplify/siderels:-Reduce) = [_t[1]*c[1]-_t[5]]}
{--> enter Groebner:-SuggestVariableOrder, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, [_t[1], _t[2], _t[3], _t[4], _t[5], _t[6]]
<-- exit Groebner:-SuggestVariableOrder (now in simplify/siderels:-simplify/siderels) = _t[6], _t[5], _t[4], _t[3], _t[2], _t[1]}
{--> enter Groebner:-Basis, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), characteristic = 0, output = basislm
{--> enter Groebner:-BasisTable, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, 0
<-- exit Groebner:-BasisTable (now in Groebner:-Basis) = table( [ ] )}
{--> enter ShortMonomialOrders:-SimilarOrders, args = plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), []
<-- exit ShortMonomialOrders:-SimilarOrders (now in Groebner:-Basis) = []}
{--> enter Groebner:-Basis, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, itord, variables = {_t[1], _t[2], _t[3], _t[4], _t[5], _t[6]}, characteristic = 0, output = basislm
value remembered (in Groebner:-Basis): Groebner:-BasisTable({_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, 0) -> table( [ ] )
{--> enter Groebner:-SuggestVariableOrder, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]], {_t[1], _t[2], _t[3], _t[4], _t[5], _t[6]}
<-- exit Groebner:-SuggestVariableOrder (now in Groebner:-Basis) = _t[6], _t[5], _t[4], _t[3], _t[2], _t[1]}
{--> enter ShortMonomialOrders:-FGBOrder, args = tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])
<-- exit ShortMonomialOrders:-FGBOrder (now in Groebner:-Basis) = [[_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]]]}
{--> enter SubstituteRootOfs:-ModuleApply, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]
<-- exit SubstituteRootOfs:-ModuleApply (now in Groebner:-Basis) = {}, {}, [], {}}
{--> enter Groebner:-LeadingTerm, args = _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5], lexdeg([_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]], [])
{--> enter LeadingTermProc:-ModuleApply, args = lexdeg([_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]], [])
<-- exit LeadingTermProc:-ModuleApply (now in Groebner:-LeadingTerm) = proc (f) lc, lm := f, 1; for i to N do lc := lcoeff(lc, vars[i], 'lmt'); lm := lm*lmt end do; lc, lm end proc}
<-- exit Groebner:-LeadingTerm (now in fgbrs:-fgb_gbasis) = 1, _t[2]*_t[3]*_t[5]}
{--> enter Groebner:-RememberBasis, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]], [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), characteristic = 0, skiptypecheck = true
value remembered (in Groebner:-RememberBasis): Groebner:-BasisTable({_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, 0) -> table( [( tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]) ) = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]] ] )
<-- exit Groebner:-RememberBasis (now in Groebner:-Basis) = }
{--> enter Groebner:-OutputBasis, args = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), true
<-- exit Groebner:-OutputBasis (now in Groebner:-Basis) = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
<-- exit Groebner:-Basis (now in Groebner:-Basis) = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
{--> enter Groebner:-OutputBasis, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), true
{--> enter LeadingTermProc:-ModuleApply, args = plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])
<-- exit LeadingTermProc:-ModuleApply (now in Groebner:-OutputBasis) = proc (f) lcoeff(f, vars, 'lm'), lm end proc}
<-- exit Groebner:-OutputBasis (now in Groebner:-Basis) = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
{--> enter Groebner:-OutputBasis, args = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), true
<-- exit Groebner:-OutputBasis (now in Groebner:-Basis) = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
<-- exit Groebner:-Basis (now in simplify/siderels:-simplify/siderels) = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
{--> enter Groebner:-NormalForm, args = [_t[3]*c[2]-_t[6]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), characteristic = 0
{--> enter Groebner:-Reduce, args = [_t[3]*c[2]-_t[6]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), s, FAIL, characteristic = 0, normalize = false
{--> enter SubstituteRootOfs:-ModuleApply, args = [[_t[3]*c[2]-_t[6]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]]
<-- exit SubstituteRootOfs:-ModuleApply (now in Groebner:-Reduce) = {}, {}, [], {}}
{--> enter F4:-NormalForm, args = [_t[3]*c[2]-_t[6]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), 0
value remembered (in initf4): LeadingTermProc:-ModuleApply(plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])) -> proc (f) lcoeff(f, vars, 'lm'), lm end proc
{--> enter ShortMonomialOrders:-VerifyOrder, args = plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])
<-- exit ShortMonomialOrders:-VerifyOrder (now in initf4) = true}
<-- exit F4:-NormalForm (now in Groebner:-Reduce) = [_t[3]*c[2]-_t[6]]}
<-- exit Groebner:-Reduce (now in Groebner:-NormalForm) = [_t[3]*c[2]-_t[6]]}
<-- exit Groebner:-NormalForm (now in simplify/siderels:-Reduce) = [_t[3]*c[2]-_t[6]]}
{--> enter Groebner:-SuggestVariableOrder, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, [_t[1], _t[2], _t[3], _t[4], _t[5], _t[6]]
<-- exit Groebner:-SuggestVariableOrder (now in simplify/siderels:-simplify/siderels) = _t[6], _t[5], _t[4], _t[3], _t[2], _t[1]}
{--> enter Groebner:-Basis, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), characteristic = 0, output = basislm
{--> enter Groebner:-BasisTable, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, 0
<-- exit Groebner:-BasisTable (now in Groebner:-Basis) = table( [ ] )}
{--> enter ShortMonomialOrders:-SimilarOrders, args = plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), []
<-- exit ShortMonomialOrders:-SimilarOrders (now in Groebner:-Basis) = []}
{--> enter Groebner:-Basis, args = {_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, itord, variables = {_t[1], _t[2], _t[3], _t[4], _t[5], _t[6]}, characteristic = 0, output = basislm
value remembered (in Groebner:-Basis): Groebner:-BasisTable({_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, 0) -> table( [ ] )
{--> enter Groebner:-SuggestVariableOrder, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]], {_t[1], _t[2], _t[3], _t[4], _t[5], _t[6]}
<-- exit Groebner:-SuggestVariableOrder (now in Groebner:-Basis) = _t[6], _t[5], _t[4], _t[3], _t[2], _t[1]}
{--> enter ShortMonomialOrders:-FGBOrder, args = tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])
<-- exit ShortMonomialOrders:-FGBOrder (now in Groebner:-Basis) = [[_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]]]}
{--> enter SubstituteRootOfs:-ModuleApply, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]
<-- exit SubstituteRootOfs:-ModuleApply (now in Groebner:-Basis) = {}, {}, [], {}}
{--> enter Groebner:-LeadingTerm, args = _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5], lexdeg([_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]], [])
{--> enter LeadingTermProc:-ModuleApply, args = lexdeg([_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]], [])
<-- exit LeadingTermProc:-ModuleApply (now in Groebner:-LeadingTerm) = proc (f) lc, lm := f, 1; for i to N do lc := lcoeff(lc, vars[i], 'lmt'); lm := lm*lmt end do; lc, lm end proc}
<-- exit Groebner:-LeadingTerm (now in fgbrs:-fgb_gbasis) = 1, _t[2]*_t[3]*_t[5]}
{--> enter Groebner:-RememberBasis, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]], [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), characteristic = 0, skiptypecheck = true
value remembered (in Groebner:-RememberBasis): Groebner:-BasisTable({_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]}, 0) -> table( [( tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]) ) = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]] ] )
<-- exit Groebner:-RememberBasis (now in Groebner:-Basis) = }
{--> enter Groebner:-OutputBasis, args = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], tdeg(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), true
<-- exit Groebner:-OutputBasis (now in Groebner:-Basis) = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
<-- exit Groebner:-Basis (now in Groebner:-Basis) = [[1, _t[2]*_t[3]*_t[5], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
{--> enter Groebner:-OutputBasis, args = [_t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), true
{--> enter LeadingTermProc:-ModuleApply, args = plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])
<-- exit LeadingTermProc:-ModuleApply (now in Groebner:-OutputBasis) = proc (f) lcoeff(f, vars, 'lm'), lm end proc}
<-- exit Groebner:-OutputBasis (now in Groebner:-Basis) = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
{--> enter Groebner:-OutputBasis, args = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), true
<-- exit Groebner:-OutputBasis (now in Groebner:-Basis) = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
<-- exit Groebner:-Basis (now in simplify/siderels:-simplify/siderels) = [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]}
{--> enter Groebner:-NormalForm, args = [_t[2]*c[1]+_t[4]*c[2]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), characteristic = 0
{--> enter Groebner:-Reduce, args = [_t[2]*c[1]+_t[4]*c[2]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), s, FAIL, characteristic = 0, normalize = false
{--> enter SubstituteRootOfs:-ModuleApply, args = [[_t[2]*c[1]+_t[4]*c[2]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]]]
<-- exit SubstituteRootOfs:-ModuleApply (now in Groebner:-Reduce) = {}, {}, [], {}}
{--> enter F4:-NormalForm, args = [_t[2]*c[1]+_t[4]*c[2]], [[1, _t[1]*_t[4]*_t[6], _t[1]*_t[4]*_t[6]+_t[2]*_t[3]*_t[5]]], plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1]), 0
value remembered (in initf4): LeadingTermProc:-ModuleApply(plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])) -> proc (f) lcoeff(f, vars, 'lm'), lm end proc
{--> enter ShortMonomialOrders:-VerifyOrder, args = plex(_t[6], _t[5], _t[4], _t[3], _t[2], _t[1])
<-- exit ShortMonomialOrders:-VerifyOrder (now in initf4) = true}
<-- exit F4:-NormalForm (now in Groebner:-Reduce) = [_t[2]*c[1]+_t[4]*c[2]]}
<-- exit Groebner:-Reduce (now in Groebner:-NormalForm) = [_t[2]*c[1]+_t[4]*c[2]]}
<-- exit Groebner:-NormalForm (now in simplify/siderels:-Reduce) = [_t[2]*c[1]+_t[4]*c[2]]}

 

Note that it is only at an exit point that we see the name of the procedure which made the call.

R;

true, [e/a, h/c]

 

 

Download trace.mw

First draft of solution procedure...

Carl Love 28035
July 03 2015
1 7

Here's a first draft of a solution procedure. For clarity, I changed the names of your N and W to Null and NotNull, and I made them the fourth and fifth (optional) arguments, respectively, and I made them sets with the empty set as the default value.

I don't know how to effectively utilize the NotNull conditions. The two commented-out lines are my attempt. They check that all denomibators are provably nonzero under the given conditions. The problem is that there are equivalent answer forms with different denominators. For example, in your example problem, the coeffcient of F[2] would probably be computed by hand as h/c, but this is equivalent, under the Null condition, to -b*e/(a*d). In the first form, we can use the NotNull condition to prove that the denominator c can't be 0, but we can't do that for the second form.

In the case of a true answer, I'd like to return numeric values for the coefficients, but I don't know how. Specifically,

Is there any Maple command that can return an exact representation of just one feasible point for a system of polynomial equations?

In other words, given any feasible point for Null, I can give you numeric values for the linear dependency coefficients. With the huge number of commands available in the relatively new package RegularChains, I'd be a little surprised if there was no feasible-point command. But I've barely scratched the surface of the help pages for this package.

ExtPolyLinearCombo:= proc(
     F::list(polynom),
     f::polynom,
     V::set(name),
     Null::set(polynom):= {},
     NotNull::set(polynom):= {}
)
local
     c, k, C:= {c[k] $ k= 1..nops(F)},
     S:= eliminate({coeffs(expand(`+`((C*~F)[]) - f), V)}, C)
;
     if
          lhs~(S[1]) <> C or
          simplify(S[2], Null) <> {0}
          # or not andmap(s-> is(denom(rhs(s)) <> 0), S[1])
          # assuming (NotNull <>~ 0)[], (Null =~ 0)[]
     then
          return false, []
     end if;

     true, eval([C[]], S[1])
end proc:

subs into a procedure...

Carl Love 28035
July 02 2015
0 0

I can't be sure about this without seeing the details of your problem, but try this:

G:= subs(FF= F(a,b,l), proc(a,b,N) add(FF, l= 1..N) end proc):

The ability to use subs like this is one of the most powerful features of the Maple language.

Let me know how that goes; like I said, I can't be sure about it. If it does work, then there's little point in having the procedure F, because it fully evaluates when passed fully symbolic arguments.

Another way, using unapply, is

G:= unapply('add'(F(a,b,l), l= 1..N), [a,b,N]);

Note that the add is enclosed in unevaluation quotes.

Reduce the timestep...

Carl Love 28035
July 02 2015
2 0

The default spacestep is 1/20 of the spatial range, which makes it .05 in your case. The default timestep is the spacestep. So the time that you're asking it to plot is less than 1/8 of a single timestep. To correct this, add the options spacestep= 1e-3 and timestep= 1e-3 to the pdsolve command. I have done this, and it does remove the negativity from the graph.

These PDE solvers are not "adaptive" like ODE solvers, meaning that they do not adjust the step size on their own.

Merged plots with plots:-display...

Carl Love 28035
July 01 2015
0 0

You can plot the region separately with plot3d and merge it with the VolumeOfRevolution plot:

R1:= plot3d([x,0,y], x= 1..exp(1), y= -ln(x)..ln(x)):

V1:= Student:-Calculus1:-VolumeOfRevolution(
     ln(x), -ln(x), x= 1..exp(1), scaling= constrained, axis= vertical, output= plot
):

plots:-display(R1,V1);

unapply...

Carl Love 28035
July 01 2015
1 1

I don't know what you mean by "avoid the singularity". Your function is singular at t=0, and there's no way to change that. Just don't try to evaluate it at 0.

Your other problem is caused by trying to differentiate with respect to a number. What you need to do is create the procedure E2 with unapply. Then the differentiations will be done symbolically. Here's your code, essentially. I removed superfluous parentheses, the (x,t)->, and the unneeded package loading.

restart:
g1:= -sqrt(t/Pi/r^3)/2 * (sin(r*(x-1)^2/4/t+Pi/4)-sin(r*(x+1)^2/4/t+Pi/4)):
g2:= int(g1, r= 1..infinity):
g3:= diff(g2,t):
g4:= diff(g2,x$2):
g5:= (g3^2+g4^2)/2:

And here's E2:

E2:= unapply(Int(g5, x= 0..100, epsilon= 1e-4, digits= 7), t):

Note the capital-I in Int. This will avoid wasting time trying symbolic integration and will go directly to numeric integration when evalf is applied. The epsilon and digits arguments will decrease the precision and increase the speed. The precision will still be adequate for a plot. The plot command is

plot(E2, 0..20, numpoints= 50, labels= [t, ``]);

This will take two to three minutes.

First 255 256 257 258 259 260 261 Last Page 257 of 395