Maple 2015 Questions and Posts

These are Posts and Questions associated with the product, Maple 2015

I'd like ot make a 3d graph that is log scaled on at least one of the axis. So far I haven't found a way of doing this that gives a graph that I genuinely like.

The following worksheet shows two ways of making the graph- the first generates the lines on the surface in a very bunched way, the second typesets the tickmarks in a very ugly way.

How can I get a graph with well placed lines and nicely typeset tickmarks?

How do other people make 3d logplots?

 

 

thing := x*log(y)*y^2*sin(1/y)^2;

x*ln(y)*y^2*sin(1/y)^2

 

 

 

``


 

Download logplot3d.mw

 

 

 

I have to generate a code for carrying out the matrix form of the revised simplex method. I have a code in place but am struggling to convert the constraints into canonical form and introduce the penalty function. If anyone has any ideas I'd be very grateful!

Best Regards

How do I make find and replace work?  Currently the replace and find button is grayed out.  What magic gets me into a state where the button can be used?

Thanks

P.S. Is there any "package" or "mode" or way some how that emacs key bindings can be made to work (including things like find and replace)?  The user interface would be much improved if I knew how to enable that.


 

diff(Q(t), t) = k*A*(T__1s(t)-T__2s(t))/d

diff(Q(t), t) = h__1(t)*A*(T__1(t)-T__1s(t))

diff(Q(t), t) = h__2(t)*A*(T__2s(t)-T__2(t))

Q(t) = m__1*c__p*(T__1i-T__1(t))

Q(t) = m__2*c__p*(T__2(t)-T__2i)

h__1(t) = k(T__1(t), T__1s(t))*(.825+.387*(g*h^3*c__p*beta(T__1(t), T__1s(t))*rho(T__1(t), T__1s(t))^2*(T__1(t)-T__1s(t))/(k(T__1(t), T__1s(t))*mu(T__1(t), T__1s(t))))^(1/6)/(1+(.492*k(T__1(t), T__1s(t))/(c__p*mu(T__1(t), T__1s(t))))^(9/16))^(8/27))^2/h

h__2(t) = k(T__2(t), T__2s(t))*(.825+.387*(g*h^3*c__p*beta(T__2(t), T__2s(t))*rho(T__2(t), T__2s(t))^2*(T__2s(t)-T__2(t))/(k(T__2(t), T__2s(t))*mu(T__2(t), T__2s(t))))^(1/6)/(1+(.492*k(T__2(t), T__2s(t))/(c__p*mu(T__2(t), T__2s(t))))^(9/16))^(8/27))^2/h

 

 

rho(T__1(t), T__1s(t)) = 999.9399+2.1082425*10^(-2)*(T__1(t)+T__1s(t))-1.77436275*10^(-3)*(T__1(t)+T__1s(t))^2+.438696375*10^(-5)*(T__1(t)+T__1s(t))^3-.6189861563*10^(-8)*(T__1(t)+T__1s(t))^4

beta(T__1(t), T__1s(t)) = -(4.216485*10^(-2)-7.097451*10^(-3)*(T__1(t)+T__1s(t))+2.63217825*10^(-5)*(T__1(t)+T__1s(t))^2-4.9518879*10^(-8)*(T__1(t)+T__1s(t))^3)/(999.9399+2.1082425*10^(-2)*(T__1(t)+T__1s(t))-1.77436275*10^(-3)*(T__1(t)+T__1s(t))^2+.438696375*10^(-5)*(T__1(t)+T__1s(t))^3-.6189861563*10^(-8)*(T__1(t)+T__1s(t))^4)
mu(T__1(t), T__1s(t)) = 2.414*10^(247.8/(.5*(T__1(t)+T__1s(t))+133)-5)

k(T__1(t), T__1s(t)) = -9.481411*10^(-6)*(T__1(t)+T__1s(t))^2+2.1356735*10^(-3)*(T__1(t)+T__1s(t))+.5599920949

 

 

rho(T__2(t), T__2s(t)) = 999.9399+2.1082425*10^(-2)*(T__2(t)+T__2s(t))-1.77436275*10^(-3)*(T__2(t)+T__2s(t))^2+.438696375*10^(-5)*(T__2(t)+T__2s(t))^3-.6189861563*10^(-8)*(T__2(t)+T__2s(t))^4

beta(T__2(t), T__2s(t)) = -(4.216485*10^(-2)-7.097451*10^(-3)*(T__2(t)+T__2s(t))+2.63217825*10^(-5)*(T__2(t)+T__2s(t))^2-4.9518879*10^(-8)*(T__2(t)+T__2s(t))^3)/(999.9399+2.1082425*10^(-2)*(T__2(t)+T__2s(t))-1.77436275*10^(-3)*(T__2(t)+T__2s(t))^2+.438696375*10^(-5)*(T__2(t)+T__2s(t))^3-.6189861563*10^(-8)*(T__2(t)+T__2s(t))^4)
mu(T__2(t), T__2s(t)) = 2.414*10^(247.8/(.5*(T__2(t)+T__2s(t))+133)-5)

k(T__2(t), T__2s(t)) = -9.481411*10^(-6)*(T__2(t)+T__2s(t))^2+2.1356735*10^(-3)*(T__2(t)+T__2s(t))+.5599920949

 

"`h__1`(t)=(-9.481411*10^(-6) (`T__1`(t)+`T__1s`(t))^(2)+2.1356735*10^(-3) (`T__1`(t)+`T__1s`(t))+0.5599920949)/(h) (0.825+(0.387 ((g h^(3) `c__p` (-(4.216485*10^(-2)-7.097451*10^(-3) (`T__1`(t)+`T__1s`(t))+2.63217825*10^(-5) (`T__1`(t)+`T__1s`(t))^(2)-4.9518879*10^(-8) (`T__1`(t)+`T__1s`(t))^(3))/(999.9399+2.1082425*10^(-2) (`T__1`(t)+`T__1s`(t))-1.77436275*10^(-3) (`T__1`(t)+`T__1s`(t))^(2)+0.438696375*10^(-5) (`T__1`(t)+`T__1s`(t))^(3)  -0.6189861563*10^(-8) (`T__1`(t)+`T__1s`(t))^(4))) (999.9399+2.1082425*10^(-2) (`T__1`(t)+`T__1s`(t))-1.77436275*10^(-3) (`T__1`(t)+`T__1s`(t))^(2)+0.438696375*10^(-5) (`T__1`(t)+`T__1s`(t))^(3)  -0.6189861563*10^(-8) (`T__1`(t)+`T__1s`(t))^(4))^(2) (`T__1`(t)-`T__1s`(t)))/((-9.481411*10^(-6) (`T__1`(t)+`T__1s`(t))^(2)+2.1356735*10^(-3) (`T__1`(t)+`T__1s`(t))+0.5599920949) 2.414*10^((247.8)/(0.5 (`T__1`(t)+`T__1s`(t))+133)-5)))^((1)/(6)))/((1+((0.492 (-9.481411*10^(-6) (`T__1`(t)+`T__1s`(t))^(2)+2.1356735*10^(-3) (`T__1`(t)+`T__1s`(t))+0.5599920949))/(`c__p` 2.414*10^((247.8)/(0.5 (`T__1`(t)+`T__1s`(t))+133)-5)))^((9)/(16)))^((8)/(27))))^(2)"

"`h__2`(t)=(-9.481411*10^(-6) (`T__2`(t)+`T__2s`(t))^(2)+2.1356735*10^(-3) (`T__2`(t)+`T__2s`(t))+0.5599920949)/(h) (0.825+(0.387 ((g h^(3) `c__p` (-(4.216485*10^(-2)-7.097451*10^(-3) (`T__2`(t)+`T__2s`(t))+2.63217825*10^(-5) (`T__2`(t)+`T__2s`(t))^(2)-4.9518879*10^(-8) (`T__2`(t)+`T__2s`(t))^(3))/(999.9399+2.1082425*10^(-2) (`T__2`(t)+`T__2s`(t))-1.77436275*10^(-3) (`T__2`(t)+`T__2s`(t))^(2)+0.438696375*10^(-5) (`T__2`(t)+`T__2s`(t))^(3)  -0.6189861563*10^(-8) (`T__2`(t)+`T__2s`(t))^(4))) (999.9399+2.1082425*10^(-2) (`T__2`(t)+`T__2s`(t))-1.77436275*10^(-3) (`T__2`(t)+`T__2s`(t))^(2)+0.438696375*10^(-5) (`T__2`(t)+`T__2s`(t))^(3)  -0.6189861563*10^(-8) (`T__2`(t)+`T__2s`(t))^(4))^(2) (`T__2s`(t)-`T__2`(t)))/((-9.481411*10^(-6) (`T__2`(t)+`T__2s`(t))^(2)+2.1356735*10^(-3) (`T__2`(t)+`T__2s`(t))+0.5599920949) 2.414*10^((247.8)/(0.5 (`T__2`(t)+`T__2s`(t))+133)-5)))^((1)/(6)))/((1+((0.492 (-9.481411*10^(-6) (`T__2`(t)+`T__2s`(t))^(2)+2.1356735*10^(-3) (`T__2`(t)+`T__2s`(t))+0.5599920949))/(`c__p` 2.414*10^((247.8)/(0.5 (`T__2`(t)+`T__2s`(t))+133)-5)))^((9)/(16)))^((8)/(27))))^(2)"

diff(Q(t), t) = k*A*(T__1s(t)-T__2s(t))/d, diff(Q(t), t) = A*(T__1(t)-T__1s(t))*(-9.481411*10^(-6)*(T__1(t)+T__1s(t))^2+2.1356735*10^(-3)*(T__1(t)+T__1s(t))+.5599920949)*(.825+.387*(((-g*h^3*c__p*(4.216485*10^(-2)-7.097451*10^(-3)*(T__1(t)+T__1s(t))+2.63217825*10^(-5)*(T__1(t)+T__1s(t))^2-4.9518879*10^(-8)*(T__1(t)+T__1s(t))^3)/(999.9399+2.1082425*10^(-2)*(T__1(t)+T__1s(t))-1.77436275*10^(-3)*(T__1(t)+T__1s(t))^2+.438696375*10^(-5)*(T__1(t)+T__1s(t))^3-.6189861563*10^(-8)*(T__1(t)+T__1s(t))^4))*((999.9399+2.1082425*10^(-2)*(T__1(t)+T__1s(t))-1.77436275*10^(-3)*(T__1(t)+T__1s(t))^2+.438696375*10^(-5)*(T__1(t)+T__1s(t))^3-.6189861563*10^(-8)*(T__1(t)+T__1s(t))^4)^2))*(T__1(t)-T__1s(t))/(2.414*10^(247.8/(.5*(T__1(t)+T__1s(t))+133)-5)*(-9.481411*10^(-6)*(T__1(t)+T__1s(t))^2+2.1356735*10^(-3)*(T__1(t)+T__1s(t))+.5599920949)))^(1/6)/(1+((.492*(-9.481411*10^(-6)*(T__1(t)+T__1s(t))^2+2.1356735*10^(-3)*(T__1(t)+T__1s(t))+.5599920949))/(2.414*c__p*10^(247.8/(.5*(T__1(t)+T__1s(t))+133)-5)))^(9/16))^(8/27))^2/h, diff(Q(t), t) = A*(T__2s(t)-T__2(t))*(-9.481411*10^(-6)*(T__2(t)+T__2s(t))^2+2.1356735*10^(-3)*(T__2(t)+T__2s(t))+.5599920949)*(.825+.387*(((-g*h^3*c__p*(4.216485*10^(-2)-7.097451*10^(-3)*(T__2(t)+T__2s(t))+2.63217825*10^(-5)*(T__2(t)+T__2s(t))^2-4.9518879*10^(-8)*(T__2(t)+T__2s(t))^3)/(999.9399+2.1082425*10^(-2)*(T__2(t)+T__2s(t))-1.77436275*10^(-3)*(T__2(t)+T__2s(t))^2+.438696375*10^(-5)*(T__2(t)+T__2s(t))^3-.6189861563*10^(-8)*(T__2(t)+T__2s(t))^4))*((999.9399+2.1082425*10^(-2)*(T__2(t)+T__2s(t))-1.77436275*10^(-3)*(T__2(t)+T__2s(t))^2+.438696375*10^(-5)*(T__2(t)+T__2s(t))^3-.6189861563*10^(-8)*(T__2(t)+T__2s(t))^4)^2))*(T__2s(t)-T__2(t))/(2.414*10^(247.8/(.5*(T__2(t)+T__2s(t))+133)-5)*(-9.481411*10^(-6)*(T__2(t)+T__2s(t))^2+2.1356735*10^(-3)*(T__2(t)+T__2s(t))+.5599920949)))^(1/6)/(1+((.492*(-9.481411*10^(-6)*(T__2(t)+T__2s(t))^2+2.1356735*10^(-3)*(T__2(t)+T__2s(t))+.5599920949))/(2.414*c__p*10^(247.8/(.5*(T__2(t)+T__2s(t))+133)-5)))^(9/16))^(8/27))^2/h, Q(t) = m__1*c__p*(T__1i-T__1(t)), Q(t) = m__2*c__p*(T__2(t)-T__2i)

diff(Q(t), t) = k*A*(T__1s(t)-T__2s(t))/d, diff(Q(t), t) = A*(T__1(t)-T__1s(t))*(-0.9481411000e-5*(T__1(t)+T__1s(t))^2+0.2135673500e-2*T__1(t)+0.2135673500e-2*T__1s(t)+.5599920949)*(.825+.387*(-.4142502071*g*h^3*c__p*(0.4216485000e-1-0.7097451000e-2*T__1(t)-0.7097451000e-2*T__1s(t)+0.2632178250e-4*(T__1(t)+T__1s(t))^2-0.4951887900e-7*(T__1(t)+T__1s(t))^3)*(999.9399+0.2108242500e-1*T__1(t)+0.2108242500e-1*T__1s(t)-0.1774362750e-2*(T__1(t)+T__1s(t))^2+0.4386963750e-5*(T__1(t)+T__1s(t))^3-0.6189861563e-8*(T__1(t)+T__1s(t))^4)*(T__1(t)-T__1s(t))/(10^(247.8/(.5*T__1(t)+.5*T__1s(t)+133)-5)*(-0.9481411000e-5*(T__1(t)+T__1s(t))^2+0.2135673500e-2*T__1(t)+0.2135673500e-2*T__1s(t)+.5599920949)))^(1/6)/(1+.4087338992*((-0.9481411000e-5*(T__1(t)+T__1s(t))^2+0.2135673500e-2*T__1(t)+0.2135673500e-2*T__1s(t)+.5599920949)/(c__p*10^(247.8/(.5*T__1(t)+.5*T__1s(t)+133)-5)))^(9/16))^(8/27))^2/h, diff(Q(t), t) = A*(T__2s(t)-T__2(t))*(-0.9481411000e-5*(T__2(t)+T__2s(t))^2+0.2135673500e-2*T__2(t)+0.2135673500e-2*T__2s(t)+.5599920949)*(.825+.387*(-.4142502071*g*h^3*c__p*(0.4216485000e-1-0.7097451000e-2*T__2(t)-0.7097451000e-2*T__2s(t)+0.2632178250e-4*(T__2(t)+T__2s(t))^2-0.4951887900e-7*(T__2(t)+T__2s(t))^3)*(999.9399+0.2108242500e-1*T__2(t)+0.2108242500e-1*T__2s(t)-0.1774362750e-2*(T__2(t)+T__2s(t))^2+0.4386963750e-5*(T__2(t)+T__2s(t))^3-0.6189861563e-8*(T__2(t)+T__2s(t))^4)*(T__2s(t)-T__2(t))/(10^(247.8/(.5*T__2(t)+.5*T__2s(t)+133)-5)*(-0.9481411000e-5*(T__2(t)+T__2s(t))^2+0.2135673500e-2*T__2(t)+0.2135673500e-2*T__2s(t)+.5599920949)))^(1/6)/(1+.4087338992*((-0.9481411000e-5*(T__2(t)+T__2s(t))^2+0.2135673500e-2*T__2(t)+0.2135673500e-2*T__2s(t)+.5599920949)/(c__p*10^(247.8/(.5*T__2(t)+.5*T__2s(t)+133)-5)))^(9/16))^(8/27))^2/h, Q(t) = m__1*c__p*(T__1i-T__1(t)), Q(t) = m__2*c__p*(T__2(t)-T__2i)

(1)

"(->)"

``

``

``

i have a system with 5 dif equations and five unknows. i have told to maple to solve it numerically with interactively solve comand (right cilck button). the window open like it normally does and i put values to my parameters, with an initial condition for the system (Q(0)=0). then i press numerically solve and that's all, the program just keep evaluating with no answer. i wait for 15 min, which i think is too much time, and got any answer yet.

hope you can help with this

thanks.. 
 

Download propuesta_transfer.mw

ha := (diff(c(t), t))/(c(t)*(diff(c(t), t))-c(t));
solve(subs(m=ha,f(m))*subs(m=subs(c(t)=a(t),ha)), f(m)) = subs(m=ha+subs(c(t)=a(t),ha), f(m), f);

just expect to find a function ?
 

1. How to generate times series data that have some logic law

but do not include distributive law?

how to fasten dsolve and is it possible to timeout faster if it know no solution earlier?

i split into near 500 blocks of nested for loop, total around 42 billions trials

i run in cmaple, 

i see it run the first 4 blocks of code and output to files,  which are daff001, daff002, daff003 and daff004

it seems that it can run parallel intelligently though i write in serial lines.

but it run a very long time, still running near first 4000 records

window 10 use 3.4GB memory, only 4GB memory rest

but 4000 records use more than 4GB memory

i just hope to run 1000 records every day, hope 1000 records can be finished within a few hours

and plan to run around 500days

 

restart:
read "D:\\daff2039mm.m":
with(combinat):
appendto("D:\\daff001.txt");
for ii from 1 to 1 do
for jj from 1 to 1 do
for kk from 1 to 1 do
if ii < jj and jj < kk then
if mm[ii] <> mm[jj] and mm[jj] <> mm[kk] then
sol := dsolve([mm[ii] , mm[jj] , mm[kk] ],[a(t), b(t), c(t)]);
if nops([sol]) = 1 then
print([mm[ii], mm[jj], mm[kk]]);
print(sol);
print(" * **");
end if:
end if:
end if:
od:
gc();
od:
od:

restart:
read "D:\\daff2039mm.m":
with(combinat):
appendto("D:\\daff002.txt");
for ii from 1 to 1 do
for jj from 1 to 1 do
for kk from 1 to 1001 do
if ii < jj and jj < kk then
if mm[ii] <> mm[jj] and mm[jj] <> mm[kk] then
sol := dsolve([mm[ii] , mm[jj] , mm[kk] ],[a(t), b(t), c(t)]);
if nops([sol]) = 1 then
print([mm[ii], mm[jj], mm[kk]]);
print(sol);
print(" * **");
end if:
end if:
end if:
od:
gc();
od:
od:

restart:
read "D:\\daff2039mm.m":
with(combinat):
appendto("D:\\daff003.txt");
for ii from 1 to 1 do
for jj from 1 to 1 do
for kk from 1001 to 2001 do
if ii < jj and jj < kk then
if mm[ii] <> mm[jj] and mm[jj] <> mm[kk] then
sol := dsolve([mm[ii] , mm[jj] , mm[kk] ],[a(t), b(t), c(t)]);
if nops([sol]) = 1 then
print([mm[ii], mm[jj], mm[kk]]);
print(sol);
print(" * **");
end if:
end if:
end if:
od:
gc();
od:
od:

restart:
read "D:\\daff2039mm.m":
with(combinat):
appendto("D:\\daff004.txt");
for ii from 1 to 1 do
for jj from 1 to 26 do
for kk from 2001 to 2001 do
if ii < jj and jj < kk then
if mm[ii] <> mm[jj] and mm[jj] <> mm[kk] then
sol := dsolve([mm[ii] , mm[jj] , mm[kk] ],[a(t), b(t), c(t)]);
if nops([sol]) = 1 then
print([mm[ii], mm[jj], mm[kk]]);
print(sol);
print(" * **");
end if:
end if:
end if:
od:
gc();
od:
od:

restart:
read "D:\\daff2039mm.m":
with(combinat):
appendto("D:\\daff005.txt");
for ii from 1 to 1 do
for jj from 26 to 51 do
for kk from 2001 to 2001 do
if ii < jj and jj < kk then
if mm[ii] <> mm[jj] and mm[jj] <> mm[kk] then
sol := dsolve([mm[ii] , mm[jj] , mm[kk] ],[a(t), b(t), c(t)]);
if nops([sol]) = 1 then
print([mm[ii], mm[jj], mm[kk]]);
print(sol);
print(" * **");
end if:
end if:
end if:
od:
gc();
od:
od:

i have already release memory with gc() in the most inner for loop ]

,but it still use up my memory

once it printed two lines each time, actually it can release memory

but why it still use up memory

read "D:\\hello.m":
with(combinat):
appendto("D:\\gogogo.txt");
for ii from 1 to 2040 do
for jj from 1 to 2040 do
for kk from 1 to 2040 do
if ii < jj and jj < kk then
if mm[ii] <> mm[jj] and mm[jj] <> mm[kk] then
sol := dsolve([mm[ii],mm[jj],mm[kk]],[a(t),b(t),c(t)]);
print([mm[ii],mm[jj],mm[kk]]);
print(sol);
print("***");
end if:
end if:
od:
gc();
od:
od:

 

i can only think

use c# to generate code with file write, nested for loop every 1000 records 

is it the only way to do?

 

int counter = 0;
for (int i=1; i<=2040; ++i)
{
for (int j = 1;j <= 2040; ++j)
{
for (int k = 1; k <= 2040; ++k)
{
if(counter % 1000 == 0)
{
Console.Write(i.ToString() + ","+j.ToString() + ","+k.ToString());
Console.Write("\r\n");
}
counter = counter + 1;
}
}
}

 

 

After using the Groebner and PolynomialIdeals packages, Maple goes into a long calculation when I make an entry of the form

name:=polynomial expression. This can take 10's of minutes for an expression of two lines. The only solution I have found is to save the sheet and restart it and enter the line name:= etc. before loading Groebner and PolynomialIdeals. This is most inconvenient. Is there a better workaround?

I would like compute the vertices of the convex hull of finitely many points in some \mathbb{R}^{n}, where the coordinates of these points could be rational numbers or irrational numbers like \sqrt{2}.

I know that PolyhedralSets[ConvexHull] is a direct command, however it does not support irrational numbers. But if I transform all coordinates into floating point numbers, for some rational numbers the rounding error would be large enough to affect the result. For example, after the transform some collinear points are no longer collinear.

Thanks!

 

 

 

how to use Riemann matrix to output Riemann surface?

and plot this surface?

 

with(algcurves):
f:=y^3+2*x^7-x^3*y;
pm:=periodmatrix(f,x,y);
evalf(pm, 5);
rm:=evalf(periodmatrix(f,x,y,Riemann),10);
M := rm;
A := proc (x, y) options operator, arrow; RiemannTheta([x, y], M, [], 0.1e-1, output = list)[2] end proc;
plot3d(Re(A(x+I*y, 0)), x = 0 .. 1, y = 0 .. 4, grid = [40, 40]);

is this graph Riemann Surface?

if so, how to convert A into polynomials?

updated:

with(CurveFitting);
f := PolynomialInterpolation([[0, x0],[1, x1],[2, x2],[3, x3],[4, x4]], x);
f2 := solve(f=y,x);
area1 := int(f, x=0..1);
with(student):
area2 := trapezoid(f2[1], x = 0..1);
with(CurveFitting);
f := PolynomialInterpolation([[0, x0],[1, x1],[2, x2],[3, x3]], x);
f2 := solve(f=y,x);
area1 := int(f, x=0..1);
with(student):
area2 := trapezoid(f2[1], x = 0..1);

 

i use 5 points trapezoid got RootOf  in result,

only 4 points is acceptable

 

when i try 5 points, there is no problem, but when more points such as

30 points, got RootOf for c sharp code

 

moreover, i got a problem when i copy the area1 result into 

visual studio c# code, it has error Integral Constant is too large

 

with(CurveFitting);
f := PolynomialInterpolation([[0, x0],[1, x1],[2, x2],[3, x3],[4, x4],[5, x5],[6, x6],[7, x7],[8, x8],[9, x9],[10, x10],[11, x11],[12, x12],[13, x13],[14, x14],[15, x15],[16, x16],[17, x17],[18, x18],[19, x19],[20, x20],[21, x21],[22, x22],[23, x23],[24, x24],[25, x25],[26, x26],[27, x27],[28, x28],[29, x29]], x);
f2 := solve(f=y,x);
area1 := int(f, y=0..1);
with(student):
area2 := trapezoid(f2[1], x = 0..1);
with(CodeGeneration):
CSharp(area1, resultname = "area1");
CSharp(area2, resultname = "area2");

i find area2 has

Warning, the function names {RootOf, Sum} are not recognized in the target language
Warning, precedence for Range unspecified
Warning, cannot translate range
area2 = RootOf((System.Double) (19276689540529530246975515949293568 * x3 - 2626509155780373903082144116707328 * x2 + 239680950855919251544490932629504 * x1 -

in internet or maple, is there a neural network package in maple?

i find example link after googled, however, still feeling not easy to apply to data.

is there the most simplest version for two columns of data ?

which algorithm can be used to mining data set in maple after feature extraction

hope systematic and automatic doing this instead of using eyes

 

i feel derived attributes are unlimited, how to know sufficient?

4 5 6 7 8 9 10 Last Page 6 of 66