acer

iterating over n...

Answered: acer 32343

March 29 2019

1 0

It seems that the solution obtained at lower values of n can provide a useful initial point for a higher value of n.

Below it's done in two ways.

The first uses this bootstrapping approach for values of n=7,13,17,18,19,20.

The second does it in a loop, using all n from 2 to 20. (slower overall, but perhaps more robust!?)

>

>	conds:=map(`=`,indets(sys,And(name,Non(constant))) minus {n},0..1);

{p[0, fail] = 0 .. 1, p[0, idle] = 0 .. 1, p[0, succ] = 0 .. 1, p[1, fail] = 0 .. 1, p[1, idle] = 0 .. 1, p[1, succ] = 0 .. 1, p[2, fail] = 0 .. 1, p[2, idle] = 0 .. 1, p[2, succ] = 0 .. 1, p[3, fail] = 0 .. 1, p[3, idle] = 0 .. 1, p[3, succ] = 0 .. 1, p[4, fail] = 0 .. 1, p[4, idle] = 0 .. 1, p[4, succ] = 0 .. 1, t[0] = 0 .. 1, t[1] = 0 .. 1, t[2] = 0 .. 1, t[3] = 0 .. 1, t[4] = 0 .. 1}

>	sol[7] := fsolve(eval(sys, n = 7), conds);

>	sol[13] := fsolve(eval(sys, n = 13), sol[7], conds);

>	sol[17] := fsolve(eval(sys, n = 17), sol[13], conds);

>	sol[18] := fsolve(eval(sys, n = 18), sol[17], conds);

>	sol[19] := fsolve(eval(sys, n = 19), sol[18], conds);

>	sol[20] := fsolve(eval(sys, n = 20), sol[19], conds);

>	eval( eval(map(lhs-rhs,sys), n=20), sol[20] );

>

#
# Automating it, but incrementing n by only 1 each iteration.
#
S[2] := fsolve(eval(sys, n = 2), conds):
for i from 3 to 20 do
  st := time();
  S[i] := fsolve(eval(sys, n = i), S[i-1], conds);
  elapsed := time()-st;
  if type(eval(S[i],1), 'specfunc(fsolve)') then
    print("failed at i=%1",i);
  else
    print(sprintf("succeeded at i=%a in %a seconds",i,elapsed));
  end if;
end do:

>

S[20];

>	eval( eval(map(lhs-rhs,sys), n=20), S[20] );

>

Download solveSYS_ac.mw

If we plot the values for each variable, in the solution as n changes, we might observe that all the curves appear linear except for p[j,fail] , j=1..4, which are monotomic and could be interpolated. I would guess that reasonably close initial points could be generated for the higher n, based on a smaller number of the solutions for lower n (which compute more quickly).
solveSYS_ac2.mw
I would not be surprised if symbolic examination of the equations could lead to a non-numeric or hybrid symbolic-numeric approach where the solutions (dependent on n) were constructed very quickly. I don't have time for that.

two ways...

Answered: acer 32343

March 28 2019

0 1

Download nz.mw

It turns out that increasing Digits up front may not be necessary here. But I include it anyway, since it may give you an idea in the future.

parse statement (multiple)...

Answered: acer 32343

March 28 2019

1 0

The help page for parse describes that the offset option can be supplied alongside the statement option, and that the lastread option allows for a running update to a specified name to hold the position least read.

Doing that in a loop allows for multiple statements to be parsed from a single string. Or you can construct a procedure to execute such a loop.

That is more robust than simply splitting the string at colons and/or semicolons, since those could appear in locations where the parsing should not be split.

An extra choice is to try and discern (and return) information about what (previously unassigned) names might have been newly assigned by this process. I realize that this may be of less relevance to your purpose, since your script that constructs the strings likely already knows to what names it will assign.

>

restart;

>

#
# This technique works even if the statement separators
# include a mix of colon and semicolon.
#
# It also works if colon or semicolon appears in places other
# than as statement separators.
#
# Since this use of `anames(user)` only detect assignments to
# names which were not yet assigned you may choose to have
# the procedure return NULL and get rid of the anames stuff.
#

>

parseall:=proc(s::string)
  local res, n, A, temp;
  A := {anames(':-user')};
  n:=0; res := [];
  while n<length(s) do
    temp := parse(s,':-lastread'='n',':-offset'=n,':-statement');
    res := [res[],[{anames(':-user')} minus A,eval(temp,1)]];
    A := {anames(':-user')};
  end do;
  res;
end proc:

>

>	data1 := "x:='x';y:='y';sol:=dsolve(diff(y(x),x)=1,y(x));":

>	out := parseall(data1);

$[[{}, x], [{}, y], [{sol}, y(x) = x+_C1]]$

>

x,y,sol;

>	# What names were just newly assigned? map[2](op,1,eval(out,1));

>	data2 := "x:='x':f:=proc(a::integer) a^2; end proc;y:='y':`g;h`;sol:=dsolve(diff(y(x),x)=1,y(x));":

>	out := parseall(data2);

$[[{}, x], [{f}, proc (a::integer) a^2 end proc], [{}, y], [{}, `g;h`], [{}, y(x) = x+_C1]]$

>

x,y,sol;

>	# What names were just newly assigned? # Notice that `sol` was already assigned, so didn't show up. map[2](op,1,eval(out,1));

>	sol := 'sol': f := 'f': out := parseall(data2);

$[[{}, x], [{f}, proc (a::integer) a^2 end proc], [{}, y], [{}, `g;h`], [{sol}, y(x) = x+_C1]]$

>	# What names were just newly assigned? map[2](op,1,eval(out,1));

>	# This first example succeeds, by splitting the string. # There is no indication of what was assigned. # eval~(parse~(StringTools:-Split(data1, ";")));

>

# This example fails, by splitting the string. It does not
# correctly interpret colons and semicolons used within
# procedures as statement separators. It also does not
# correctly interpret colons and semicolons appearing other
# than as statement separators.
#
eval~(parse~(StringTools:-Split(data2, ";")));

Warning, extra characters at end of parsed string

Error, incorrect syntax in parse: reserved word `end` unexpected (near 4th character of parsed string)

>	map(lprint, StringTools:-Split(data2, ";")):

"x:='x':f:=proc(a::integer) a^2"
" end proc"
"y:='y':`g"
"h`"
"sol:=dsolve(diff(y(x),x)=1,y(x))"
""

Download parsestatements.mw

By "newly assigned" I mean unassigned before the call. I don't mean re-assigned.

evalhf...

Answered: acer 32343

March 27 2019

0 0

The error message describes the situation: the Int call is not supported by evalhf.

Did you just want to make it faster? Note that the quadrature scheme can utilize evalhf for the evaluations of the integrand.

>

restart; f1 := proc (XX::Array) local GG, i; GG := 0; for i to 500 do GG := GG+Int(z^2/(1000*XX[i]-z)^2, z = 0 .. 100) end do; return GG end proc; A1 := Array(1 .. 500, [seq(-i^2+100-1, i = 1 .. 500)]); CodeTools:-Usage(evalf(f1(A1)))

memory used=34.63MiB, alloc change=6.01MiB, cpu time=180.00ms, real time=188.00ms, gc time=12.68ms

>

restart; f1 := proc (XX::Array) local i; add(evalf(Int(z^2/(1000*XX[i]-z)^2, z = 0 .. 100, method = _d01ajc)), i = 1 .. 500) end proc; A1 := Array(1 .. 500, [seq(-i^2+100-1, i = 1 .. 500)]); CodeTools:-Usage(f1(A1))

memory used=13.34MiB, alloc change=2.00MiB, cpu time=73.00ms, real time=81.00ms, gc time=0ns

>

infolevel[`evalf/int`] := 2; forget(evalf); evalf(Int(z^2/(1000*A1[2]-z)^2, z = 0 .. 100, method = _d01ajc)); infolevel[`evalf/int`] := 0

evalf/int/control: integrating on 0 .. 100 the integrand

z^2/(95000-z)^2

Control: Entering NAGInt
trying d01ajc (nag_1d_quad_gen)
d01ajc: trying evalhf callbacks
d01ajc: result=.369928326560882854e-4
d01ajc: abserr=.205351472804473049e-18; num_subint=1; fun_count=21
result=.369928326560882854e-4

>

Download evalhf_int_ac.mw

Or do you have other computations to go inside procedure f1, which you also want done under evalhf?

different...

Answered: acer 32343

March 27 2019

2 7

The subs command does syntactic substituion without evaluation (unless the command name is indexed by the key eval).

The eval command does a more mathematical substitution, in the sense that it has additional knowledge of the mathematics germane to some substitutions.

Often the two produce the same result. Sometimes one specifically wants to avoid evaluation prior to being able to do subsequent manipulations of the result.

Sometimes subs is a bit faster. Relying on that only makes sense up to the situations where one doesn't need the mathematical knowledge.

subs(x=1.2, sin(x));
                         sin(1.2)

subs[eval](x=1.2, sin(x));
                       0.9320390860

eval(sin(x), x=1.2);
                       0.9320390860

There are also differences in how substitutions are done. The subs command allows you to do them together or in sequence. Eg,

subs([a=b,b=c], [a,b]);
                          [b, c]

subs(a=b,b=c, [a,b]);
                          [c, c]

subs(b=c,a=b, [a,b]);
                          [b, c]

eval([a,b], [a=b,b=c]);
                          [b, c]

I'm not sure which aspects are most relevant to your query. There are other subtleties or examples which might interest you.

Threads:-Seq, Threads:-Task...

Answered: acer 32343

March 27 2019

0 4

I ran the code below on an Intel i7-7700 3.60GHz which has 4 physical cores with hyperthreading (8 threads or logical cores). Since Maple doesn't recognize this as having "new" improved hyperthreading it sets kernelopts(numcpus) to 4 by default. So in some of the examples below I set kernelopts(numcpus) to 7 and kernelopts(gcmaxthreads) to 7 or 8 (which seems optimal on this host for some examples).

I also ran it on an Intel i5-7400 3.00GHz which has 4 physical cores without hyperthreading (4 threads or logical cores). The relative timing behavior amongst the example was generally the same, except timings were not as good. I left kernelopts(numcpus) and kernelopts(gcmaxthreads) alone, at their default value of 4, since raising those resulted in worse performance.

I did all that using 64bit Maple 2019.0 on Linux.

I observed that almost half of the total computation time is spent in memory management (garbage collection). I found that by reducing the setting of kernelopts(gcthreadmemorysize) from its default I could improve the total timing. This benefit seemed to happen across other setting variants.

I made sure that the machines were not otherwise significantly loaded, since the timing measurements are in real (wall clock) time. I made sure that for size nelems=10^7 the machines had at least 2.5GB of free RAM and so would not swap out the computation.

One interesting result is that simple use of Threads:-Seq attained almost as good performance as the more complicated Threads:-Task set up, under the tweaked kernelopts settings.

For the Threads:-Task set up I tried to ensure that few temporary Arrays were created (ie. without concatenation). The exception to that was that I did not find improvement for replacing seq calls with inplace map calls or straight Array construction with initializer.

>

restart;
'numcpus'=kernelopts(numcpus), 'gcmaxthreads'=kernelopts(gcmaxthreads),
'gcthreadmemorysize'=kernelopts(gcthreadmemorysize);

nelems := 10000000:
n := 374894756873546859847556:

str,sgctr := time[real](), kernelopts(gctotaltime[real]):
A := Array(1 .. 4, 1 .. nelems):
A[1,1..nelems] := Array([seq( i^10*n, i=1..nelems)]):
A[2,1..nelems] := Array([seq( length(A[1,i])-1, i=1..nelems)]):
A[3,1..nelems] := Array([seq(iquo(A[1,i], 10^(A[2,i]-2)),i=1..nelems)]):
A[4,1..nelems] := Array([seq(irem(A[1,i],1000),i=1..nelems)]):
RT,GCRT := time[real]()-str, kernelopts(gctotaltime[real])-sgctr:
print(sprintf("total real time: %a secs gc real time: %a secs",
evalf[4](RT), evalf[4](GCRT)));

>

restart;
kernelopts(numcpus=7): kernelopts(gcmaxthreads=7): kernelopts(gcthreadmemorysize=2^17):
'numcpus'=kernelopts(numcpus), 'gcmaxthreads'=kernelopts(gcmaxthreads),
'gcthreadmemorysize'=kernelopts(gcthreadmemorysize);

nelems := 10000000:
n := 374894756873546859847556:

str,sgctr := time[real](), kernelopts(gctotaltime[real]):
A := Array(1 .. 4, 1 .. nelems):
A[1,1..nelems] := Array([seq(i^10*n, i=1..nelems)]):
A[2,1..nelems] := Array([seq(length(A[1,i])-1, i=1..nelems)]):
A[3,1..nelems] := Array([seq(iquo(A[1,i], 10^(A[2,i]-2)),i=1..nelems)]):
A[4,1..nelems] := Array([seq(irem(A[1,i],1000),i=1..nelems)]):
RT,GCRT := time[real]()-str, kernelopts(gctotaltime[real])-sgctr:
print(sprintf("total real time: %a secs gc real time: %a secs",
evalf[4](RT), evalf[4](GCRT)));

>

restart;
kernelopts(numcpus=7): kernelopts(gcmaxthreads=7): kernelopts(gcthreadmemorysize=2^17):
'numcpus'=kernelopts(numcpus), 'gcmaxthreads'=kernelopts(gcmaxthreads),
'gcthreadmemorysize'=kernelopts(gcthreadmemorysize);

nelems := 10000000:
n := 374894756873546859847556:

str,sgctr := time[real](), kernelopts(gctotaltime[real]):
A := Array(1 .. 4, 1 .. nelems):
A[1,1..nelems] := Array([Threads:-Seq(i^10*n, i=1..nelems)]):
A[2,1..nelems] := Array([Threads:-Seq(ilog10(A[1,i]), i=1..nelems)]):
A[3,1..nelems] := Array([Threads:-Seq(iquo(A[1,i], 10^(A[2,i]-2)),i=1..nelems)]):
A[4,1..nelems] := Array([Threads:-Seq(irem(A[1,i],1000),i=1..nelems)]):
RT,GCRT := time[real]()-str, kernelopts(gctotaltime[real])-sgctr:
print(sprintf("total real time: %a secs gc real time: %a secs",
evalf[4](RT), evalf[4](GCRT)));

>

restart;
kernelopts(numcpus=7): kernelopts(gcmaxthreads=7): kernelopts(gcthreadmemorysize=2^17):
'numcpus'=kernelopts(numcpus), 'gcmaxthreads'=kernelopts(gcmaxthreads),
'gcthreadmemorysize'=kernelopts(gcthreadmemorysize);

subtask := proc(lo,hi,AA,nn) local i;
  AA[1,lo..hi] := Array([seq(i^10*n, i=lo..hi)]);
  AA[2,lo..hi] := Array([seq(length(AA[1,i])-1, i=lo..hi)]);
  AA[3,lo..hi] := Array([seq(iquo(AA[1,i],10^(AA[2,i]-2)), i=lo..hi)]);
  AA[4,lo..hi] := Array([seq(irem(AA[1,i],1000), i=lo..hi)]);
  return NULL;
end proc:
fulltask := proc(num::posint,n::posint,N::posint) local A,i;
  A := Array(1..4,1..num,order=C_order);
  Threads:-Task:-Start(null, Task=[subtask, 1, ceil(num/N), A, n],
                       seq(Task=[subtask, ceil((i-1)*num/N)+1, ceil(i*num/N), A, n],
                           i=2..N));
  return A;
end proc:

nelems := 10000000:
n := 374894756873546859847556:
N := kernelopts(numcpus):
A,RT,GCRT := CodeTools:-Usage( Threads:-Task:-Start( fulltask, nelems, n, N),
                               output=[output, realtime, gcrealtime], quiet ):
print(sprintf("total real time: %a secs   gc real time: %a secs",
              evalf[4](RT), evalf[4](GCRT)));

>

Download threadthingm.mw

On these Linux machines the best performing variant above was about 3.1 times as fast as the first (unoptimzed) variant. The timings do change slightly upon re-execution, however. It was also faster than other versions posted so far for this Question. It would be interesting to see results for a 4-core (modern) hyperthreaded host on 64bit MS-Windows.

parametric, real...

Answered: acer 32343

March 27 2019

1 1

Using Maple versions 17.02 (2013) through to 2019.0,

solve([x^2+y^2+z^2-4*x+6*y-2*z-11 = 0, 2*x+2*y-z = -18],
      [x, y, z], parametric, real);

           [[x = -4/3, y = -19/3, z = 8/3]]

embedded components, context-menu...

Answered: acer 32343

March 27 2019

0 0

Widget driven interface (displayed inline in worksheet in Maple GUI or Maple Cloud or Maple Player, created via source or mouse layout):
Embedded Components, a newer alternative to Maplets
See Help topics:
- EmbeddedComponents
- examples,ProgrammaticContentGeneration
- DocumentTools,Layout
"Clickable Math" access to commands applied to 2D output or input (right-click popup menu in Maple 2017 and earlier, and side-panel menu in Maple 2018 and later):
customized Context-Menu entries
See Help topics:
- ContextMenu
- examples,ContextMenu
See more ideas:
- package-specific context-menu additions
- context-menu additions for "phasor" package (see ModuleLoad)
- context driven help

more workarounds...

Answered: acer 32343

March 25 2019

2 3

Here are a few more workarounds.

restart;
solve({x^2 = 2, x^3 = sqrt(2)^3}, [x,W]):
subs((W=W)=NULL, %);

                         [[     (1/2)]]
                         [[x = 2     ]]

Of course, these next two are restricted to a particular kind of problem or domain.

restart;
SolveTools:-PolynomialSystem({x^2 = 2, x^3 = sqrt(2)^3});

                          /     (1/2)\ 
                         { x = 2      }
                          \          / 

restart;
solve({x^2 = 2, x^3 = sqrt(2)^3}, [x], real);

                         [[     (1/2)]]
                         [[x = 2     ]]

When solve behaves weirdly I usually look at eliminate as well.

randomize...

Answered: acer 32343

March 23 2019

0 0

Call the randomize command first with the same seed value.

collect...

Answered: acer 32343

March 22 2019

0 0

>

restart:

>	kernelopts(version);

(1)

>	with(DETools):

>	a1:=m^2((1-N)/(2-N))(r/2)Dp: a2:=((1-N)m^2/(2-N))((G[r](Nb-Nt)/64)(r^5/6-h^2r/2)-(B[r]/4)(r^3/4-h^2r/2)(Nt/Nb)): a3:=a1-a2: a4:=r^2a3: DE1:=r^2diff(v(r),r,r)+rdiff(v(r),r)-(m^2r^2+1)v(r)=a4:

>	b1:=dsolve(DE1,v(r));

v(r) = BesselI(1, m*r)*_C2+BesselK(1, m*r)*_C1-(1/128)*(-1+N)*((G[r]*(-(1/3)*r^4+h^2)*Nb^2+(-(-(1/3)*r^4+h^2)*Nt*G[r]+64*Dp)*Nb-16*B[r]*(h^2-(1/2)*r^2)*Nt)*m^4+(-8*Nb^2*r^2*G[r]+8*Nb*Nt*r^2*G[r]+64*Nt*B[r])*m^2-64*Nb*G[r]*(Nb-Nt))*r/(Nb*m^4*(-2+N))

(2)

>	sort(N-1,order=plex(N)): sort(N-2,order=plex(N)):

>

>	F:=proc(u) local hu,ho; if u::`` then hu,ho:=selectremove(t->depends(t,[r,m]) or t::rational,u); sort(expand(``(op(hu))),order=plex(r))``(op(ho)); else u; end if; end proc:

>

>	collect(rhs(b1), [BesselI, BesselK, G[r], B[r]], u->F(simplify(u,size)));

BesselI(1, m*r)*_C2+BesselK(1, m*r)*_C1+((1/384)*r^5+(1/16)*r^3/m^2-(1/128)*h^2*r+(1/2)*r/m^4)*(N-1)*(Nb-Nt)*G[r]/(N-2)+(-(1/16)*r^3+(1/8)*h^2*r-(1/2)*r/m^2)*(N-1)*Nt*B[r]/(Nb*(N-2))-(N-1)*Dp*r/(2*N-4)

(3)

>

Download collect_example.mw

[edit] That F procedure is only there to get the polynomial terms in r in the form you showed. You may wish to omit it. Ie,

animation...

Answered: acer 32343

March 20 2019

0 0

Is this what you want?

>

restart;

>	with(plots):

>	R := 5; alpha := (1/9)Pi; beta := (1/3)Pi; n := 100; dt := 2*Pi/n;

>	C1 := plot([Rcos(t), Rsin(t), t = 0 .. 2*Pi], color = blue):

>	local O := [0, 0];

>	M := [Rcos(beta), Rsin(beta)];

>	OM := plot([O, M]):

>	A := [Rcos(alpha), Rsin(alpha)];

>	B := [Rcos(alpha+Pi), Rsin(alpha+Pi)];

>	AB := plot([A, B]):

>	P := [Rcos(t0dt), Rsin(t0dt)];

>	Q := [Rcos(dtt0+Pi), Rsin(dtt0+Pi)];

>	tp := textplot([[A[1]+.3, A[2], "A"], [B[1]-.3, B[2], "B"], [M[1]+.3, M[2]+.3, "M"]]):

>

>	all := [seq(display(AB, OM, C1, tp, plot([M, P]), plot([M, Q]), plot([P, Q], color = green)), t0 = 0 .. n)]:

>

>	display(all, insequence = true);

OManim.mw

idea...

Answered: acer 32343

March 20 2019

0 1

The behavior in this attachment may be what the author of Statistics:-DataSummary had intended.

QuestionDataWeights_acc.mw

A more robust way to discern the position of the weights optional parameter could be devised. I only checked against Maple 2019.0, Maple 2018.0 and Maple 2018.2, but chances are reasonable that weights corresponds to either PARAM(4) or PARAM(5) of the InertForm in earlier versions that have DataSummary.

I use the ToInert/subsop/FromInert to repair what seems like a typo in the source of DataSummary. On the source line of that assigns to w,ww the first argument passed to PreProcessData is edited from X to weights. See showstat(Statistics:-DataSummary) for clarification.

I'll submit a bug report.

Array initializer...

Answered: acer 32343

March 19 2019

0 0

The use of nested loops to assign distinct deep copies of a Record to the Array entries seems somewhat unnatural and stilted to me.

The Array command accepts an initializer procedure as an optional argument, which can be used to populate each entry. The distinct Records (and Vectors in their fields) can be created on the fly.

This gets rid of the need for nested loops (as many as there are dimensions) to assign all the entries their Records. It gets rid of the need for copy or deep copying of a Record. The values of the indices (i,j,k) could be passed to the constructing procedure, in the case that some Record field were desired to be set up depending on their values.

The Records could also share some Vector(s), if desired. The copy approach gets in the way of that.

>

restart;

>

create_nodeprop := () -> Record(

                    'inode'      = 0 ,
                    'nnb'        = 6 ,
                    'nind'       = Vector( 1 .. 6 , 0 ) ,
                    'U'          = 100. ,
                    'Ul'         = 100. ,
                    'Uprev'      = 100. ,
                    'Ueq'        = 100. ,
                    'Ueql'       = 100. ,
                    'blin'       = 0.   ,
                    'q'          = 0.   ,
                    'rx'         = 2.   ,
                    'ry'         = 2.   ,
                    'rz'         = 2.   ,
                    'rfin'       = Vector( 1 .. 6 , -1. ) ,
                    'conduct'    = Vector( 1 .. 6 , -1. ) ,
                    'c'          = 2.   ,
                    'tau'        = 0.   ,
                    'k'          = 0.   ,
                    'sumconduct' = 0.   ,
                    'sharedB'    = `if`(B::rtable,ArrayTools:-Alias(B),NULL)
                  ) :

>	nx := 10 : # X direction dimension. ny := 4 : # Y direction dimension. nz := 1 : # Z direction dimension.

>

>	B := Vector([1,2,3,4]):

>

>	node := Array( 1 .. ny , 1 .. nx , 1 .. nz, (i,j,k) -> create_nodeprop() ) :

>	ic := 0 : for k from 1 to nz do for j from 1 to ny do for i from 1 to nx do ic := ic + 1 : node[ j , i , k ]:-inode := ic : od : # for i from 1 to nx do od : # for j from 1 to ny do od : # for k from 1 to nz do

>

for k from 1 to nz do
    for j from 1 to ny do
        for i from 1 to nx do

            ic := 0 :

#          +X
            if ( i + 1 <= nx ) then
                 ic := ic + 1 :
                 node[ j , i , k ]:-nind[ic] := node[ j , i + 1 , k ]:-inode :
            end if : # if ( i + 1 <= nx )

#          -X
            if ( 1 <= i - 1 ) then
                 ic := ic + 1 :
                 node[ j , i , k ]:-nind[ic] := node[ j , i - 1 , k ]:-inode :
            end if : # if ( 1 <= i - 1 )

#          +Y
            if ( j + 1 <= ny ) then
                 ic := ic + 1 :
                 node[ j , i , k ]:-nind[ic] := node[ j + 1 , i , k ]:-inode :
            end if : # if ( j + 1 <= ny )

#          -Y
            if ( 1 <= j - 1 ) then
                 ic := ic + 1 :
                 node[ j , i , k ]:-nind[ic] := node[ j - 1 , i , k ]:-inode :
            end if : # if ( 1 <= j - 1 )

#          +Z
            if ( k + 1 <= nz ) then
                 ic := ic + 1 :
                 node[ j , i , k ]:-nind[ic] := node[ j , i , k + 1 ]:-inode :
            end if : # if ( k + 1 <= nz )

#          -Z
            if ( 1 <= k - 1 ) then
                 ic := ic + 1 :
                 node[ j , i , k ]:-nind[ic] := node[ j , i , k - 1 ]:-inode :
            end if : # if ( 1 <= k - 1 )

            node[ j , i , k ]:-nnb := ic : # Store number of neighbors.

        od : # for i from 1 to nx do
     od : # for j from 1 to ny do
od : # for k from 1 to nz do

>	node[2,3,1]:-nind

node[2,3,1]:-nind should be [ 14 , 12 , 23 , 3 , 0 , 0 ]

>	node[3,6,1]:-nind

node[ 3,6,1 ]:-nind should be [ 27 , 25 , 36 ,16 , 0 , 0 ]

>	node[ 1 , 1 , 1 ]:-inode;

>	node[ 2 , 2 , 1 ]:-inode;

We've already seen that the Records get their own distinct Vectors.

But they can also share certain designated Vectors.

>	node[1,2,1]:-sharedB[3] := 27:

>	node[4,3,1]:-sharedB;

We can even unassign the name global name `B`, for re-use.

>

B := 'B';

>	node[4,3,1]:-sharedB[2] := 64:

>	node[1,2,1]:-sharedB;

>

Download Why_initializer.mw

GAMMA...

Answered: acer 32343

March 17 2019

0 7

Are you looking for something like this?

GAMMA(3/2);

                      1/2
                    Pi
                    -----
                      2

convert((x)!, GAMMA);

                 GAMMA(x + 1)                                                  
                                                                                                              
convert((1/2)!, GAMMA);

                      1/2
                    Pi
                    -----
                      2

E-Mail Address:
Password:
Remember Me:	Automatically sign in on future visits

E-Mail Address:
Password:
Remember Me:	Automatically sign in on future visits

Ask a Question

Create a Post

32343 Reputation

29 Badges

Social Networks and Content at Maplesoft.com

MaplePrimes Activity

These are answers submitted by acer

iterating over n...

two ways...

parse statement (multiple)...

evalhf...

different...

Threads:-Seq, Threads:-Task...

parametric, real...

embedded components, context-menu...

more workarounds...

randomize...

collect...

animation...

idea...

Array initializer...

GAMMA...

Save this setting as your default sorting preference?

Ask a Question

Create a Post

Generating PDF…

Save this setting as your default sorting preference?
Note: You can change your preference any time in your account settings
Don't show this again