dharr

something...

Answered: dharr 8205

July 22 2023

2 1

Here's a small step in the right direction.

>

restart;

>	eq:=erf(x)=erf(Pi);

Define inverse function

>	inverf:=erf@@(-1);

Apply it to both sides of the equation

>	map(inverf,eq);

>	solve(inverf(erf(x))=inverf(erf(Pi)),x);

But inverf isn't a linear function, so we don't expect anything more complicated to work.

>	inverf(erf(x)-erf(Pi))=inverf(0);

>

Download inverf.mw

Can be positive semidefinite...

Answered: dharr 8205

July 20 2023

3 1

The following parameters make it positive semidefinite:

My procedure was pretty ad-hoc, using Satisfy and just adding conditions until it worked.

positivedefinite.mw

@mmcdara - I think you needed C[1]<=0, but in 2015 it didn't lead to a solution even when I made that change, 2023 just gave one solution when solving the conditions. Since the matrix is symmetric, the discriminants of the quadratics have to be positive anyway, and the signs of the coefficents can be used to test for two positive roots. But I don't really see why your method gave a different result.

@sursumCorda I'd be suspicious of the deprecated linalg routine. All principal minors (of all sizes) need to non-neg, so perhaps systematically working through these would be a better method.

datasetlabels = contents...

Answered: dharr 8205

July 03 2023

1 0

Use datasetlabels = contents for this, but it isn't pretty.

Functorial composition in combstruct...

Answered: dharr 8205

July 02 2023

0 0

The short answer is that there is no obvious way to do this. You can certainly make subsets and two-element subsets as you have described if you are using labeled structures (and exponential generating functions). But the OEIS series you gave is for unlabelled graphs, so I don't see how it could arise from labelled structures. The combstruct package takes a grammar and then enumerates for either labeled or unlabelled structures but not for a mixture.

I don't really understand the functorial composition. But as far as I can see, there doesn't seem to be a simple way that its generating function is related to the generating function of the operands, and the basis of the combstruct package is that the grammar translates directly to operations on generating functions.

(If your object is just to calculate the numbers in the OEIS series, that can be done through Polya counting and can be programmed in Maple.)

improved labels...

Answered: dharr 8205

June 28 2023

1 0

For consistency in the A and nA labels, use MathML for both, so set A:=`#mo(A)` (or use mi for both A and nA if you want italics). I also added padding=10 to StyleVertex so the lines don't touch the labels.

For the weight locations you could use GetVertexPositions and then programmatically adjust the locations for the colored edges to have the same y value as the corresponding uncolored ones, and then save with SetVertexPostions. But that is a lot of work, and for me the weights look OK already.

Arbrepondéré.mw

dchange...

Answered: dharr 8205

June 24 2023

3 15

Perhaps could be done in fewer steps, but this works.

Note: I scaled the result arbitrarily to make it simpler, under the assumption that it is was intended to be equal to zero, but you can leave that out.

>

restart:

>	local gamma;

>

eqn := (diff(theta(x, z, t), x))^2*(K[1]-K[3])*cos(theta(x, z, t))*sin(theta(x, z, t))+(diff(theta(x, z, t), x))*((diff(theta(x, z, t), z))*(-K[1]*cos(2*theta(x, z, t))+K[3]*cos(2*theta(x, z, t)))-(1/2)*gamma[1]*(4*sin(theta(x, z, t))^2*u(x, z, t)+2*u(x, z, t)*cos(2*theta(x, z, t))))+(diff(theta(x, z, t), z))^2*(K[3]-K[1])*cos(theta(x, z, t))*sin(theta(x, z, t))-(1/2)*gamma[1]*(diff(theta(x, z, t), z))*(4*sin(theta(x, z, t))^2*v(x, z, t)+2*v(x, z, t)*cos(2*theta(x, z, t)))+(diff(theta(x, z, t), z, x))*(-2*K[1]+2*K[3])*cos(theta(x, z, t))*sin(theta(x, z, t))-(diff(u(x, z, t), z))*((1/2)*gamma[2]*cos(2*theta(x, z, t))+(1/2)*gamma[1]*(2*sin(theta(x, z, t))^2+cos(2*theta(x, z, t))))-(diff(v(x, z, t), x))*((1/2)*gamma[2]*cos(2*theta(x, z, t))+(1/2)*gamma[1]*(-2*sin(theta(x, z, t))^2-cos(2*theta(x, z, t))))-(1/2)*gamma[1]*(4*sin(theta(x, z, t))^2*(diff(theta(x, z, t), t))+2*(diff(theta(x, z, t), t))*cos(2*theta(x, z, t)))+((diff(u(x, z, t), x))*gamma[2]-(diff(v(x, z, t), z))*gamma[2])*cos(theta(x, z, t))*sin(theta(x, z, t))+f[2](theta(x, z, t))*(diff(theta(x, z, t), x, x))+f[1](theta(x, z, t))*(diff(theta(x, z, t), z, z));

Change the independent variables first

>	tr1:={t = Ttau,x = Xh, z = Zh}; eqn2:=PDEtools:-dchange(tr1, eqnT*h^2, [tau,X,Z],params=[T,h],simplify);

Now the dependent variables

>	tr2:={u(tau,X,Z) = xih^2U(tau,X,Z)/alpha[4], v(tau,X,Z) = xih^2V(tau,X,Z)/alpha[4]}; eqn3:=PDEtools:-dchange(tr2, eqn22alpha[4], [U,V],params=[xi,h,alpha[4]],simplify);

${u(tau, X, Z) = xi*h^2*U(tau, X, Z)/alpha[4], v(tau, X, Z) = xi*h^2*V(tau, X, Z)/alpha[4]}$

Now the rest, assuming f[1](theta(x, z, t)) was really intended as a function and not as multiplying by f[1] (same for f[2])

>	tr3 := {K[3] = K[1]k[3], f[1](theta(x, z, t)) = K[1]F[1](theta(x, z, t)), f[2](theta(x, z, t)) = K[1]F[2](theta(x, z, t)), gamma[1] = muGamma[1], gamma[2] = mu*Gamma[2]}; eqn4:=PDEtools:-dchange(tr3, eqn3, [k[3], F[1], F[2], Gamma[1], Gamma[2]],params=[K[1],mu],simplify);

>

Download dchange.mw

integers but not very random...

Answered: dharr 8205

June 22 2023

1 2

Well, all but 2 are random...

>

restart;

>	with(LinearAlgebra):

Choose determinant required and Matrix size:

>	det:=9;n:=4;

Try to adjust 1,1 and 1,2 entries until it works. Values can be too high to look random - could play with the q values

>

imax:=10:
for i to imax do
  R:=RandomMatrix(n,n,generator=-5..5):
  R[1,1]:=a:
  R[1,2]:=b:
  eq:=isolve(Determinant(R)=det,q);
until eq<>NULL:
if i>imax then
  print(`too hard`);
else
  print(i);
  R:=eval(R,eval(eq,q=0));
  R:=eval(R,indets(R,name)=~0); # if there is an a or b left, set = 0
  Determinant(%);
end if;

Matrix(%id = 36893490371187920396)

>

Download GivenDet.mw

Zeon algebra...

Answered: dharr 8205

June 21 2023

1 0

See also the thread here
How-To-Obtain-All-Cycles--In-A-Graph

>

Using the adjacency matrix and zeons to count cycles.

See R. Schott and G.S. Staples, Complexity of counting cycles using zeons, Comp. Math. Appl. 62 (2011) 1828–1837, doi: 10.1016/j.camwa.2011.06.026

Zeons implemented with bitwise operations on Maple integers in the Bits package.

>

Setting a bit in an integer.

>

Warning, (in SetBits) `i` is implicitly declared local

>

Going back

>

The algorithm starts with two versions of the adjacency matrix. Matrix B has the (i,j) entry as a coded version of i and j that is the beginning of a path or cycle.

Matrix A entry (i,j) has only the coded versionsof j; this is the vertex that will be added to the path at each step by evaluating B.A with a special rule for multiplication.

At any stage the list in entry (i,j) of B contains integers representing possible paths between i and j of a certain length k.

>

Adj := AdjacencyMatrix(G); A := Matrix(n, n, proc (i, j) options operator, arrow; if Adj[i, j] = 1 then SetBit(j) else 0 end if end proc); B := Matrix(n, n, proc (i, j) options operator, arrow; if Adj[i, j] = 1 then [Or(SetBit(i), SetBit(j))] else [] end if end proc); B, A

Matrix(%id = 36893490887404493628), Matrix(%id = 36893490887404491348)

Consider a list of two paths of length 2 from vertex 1 to vertex 3: 1-2-3 and 1-7-3 that would be in entry (1,3). Part of the next step would be trying to add vertex 7 to each of these paths.

>

The multiplication of two entries in the process of Matrix multiplication adds the a vertex to each of the possibilities in b. If it is a repeated vertex, then the possibility disappears. A duplicate is detected as the And of two values being nonzero. Adding the vertex is done by Or

>

And(7, 64); And(69, 64); Or(7, 64); Decode(%)

Note that although we add the vertex, we lose information about the order. So this algorithm cannot output the cycles themselves. The following implements this multiplication.

>	map((x,y)-> if Bits:-And(x,y)=0 then Bits:-Or(x,y) else NULL end if,b,a);

A repeatng vertex isn't necessarily a cycle; only if the starting and ending vertex are the same. This will happen if we are multplying B[i,j]*A[j,p] with i=p, i.e., we are calculating a diagonal entry.

To prevent double counting, we only keep the cycle if the smallest vertex is i. The full multiplication rule is

>

mult:=(x,y)->if y = 0 or x=[] then []
             else
               map((u,w)-> if Bits:-And(u,w)=0 then
                              return Bits:-Or(u,w)
                           else
                              if i=p and i=Bits:-FirstNonzeroBit(u) + 1 then record_cycle end if;
                              return NULL;
                           end if,
                    x,y)
             end if:

Implement the Matrix multiplication with the above routine

>	MM:=proc(B,A) local C,i,j,p; C:=Matrix(n,n): for i to n do # rows of B diving down for p to n do # cols of A C[i,p]:=[seq(mult(B[i,j],A[j,p])[],j=1..n)]; #Row(B,i).Column(A,p) end do end do: C end proc:

>

Matrix(%id = 36893490887341852180)

Next one

>

B := C; C := MM(B, A); Show(C)

Matrix(%id = 36893490887341836396)

And again

>

B := C; C := MM(B, A); Show(C)

Matrix(%id = 36893490887253294844)

So here is a procedure to count cycles in a graph or digraph.

Output is a sparse table, indexed by the number of vertices in the cycles

Use add(eval(CycleCounts(G))) to find the total number of cycles.
This includes 2-cycles, one for each edge, so subtract the number of edges if you do not want 2-cycles in the total.

For undirected graphs, some authors count each cycle twice, one in each orientation, but here each cycle is counted only once.

>

CycleCounts:=proc(G::Graph)
  uses GraphTheory;
  local k,A,B,C,p,n,i,j,mult,cycles,SetBit;
  cycles:=table('sparse');
  n:=NumberOfVertices(G);
  SetBit := m-> Bits:-Join(convert(Vector(n, {m = 1}, 'fill' = 0), list));
  mult:=(x,y)->if y = 0 or x = [] then []
             else
               map((u,w)-> if Bits:-And(u,w)=0 then
                              return Bits:-Or(u,w)
                           else
                              if i=p and i=Bits:-FirstNonzeroBit(u) + 1 then cycles[k]++ end if;
                              return NULL;
                           end if,
                    x,y)
             end if;
  A:=Matrix(n,n, (i, j)-> if AdjacencyMatrix(G)[i, j] = 1 then SetBit(j) else 0 end if);
  B:= Matrix(n,n, (i, j)-> if AdjacencyMatrix(G)[i, j] = 1 then {Bits:-Or(SetBit(i),SetBit(j))} else [] end if);
  for k from 2 to n do
    C:=Matrix(n,n):
    for i to n do # rows of B diving down
      for p to n do # cols of A
        C[i,p]:=[seq(mult(B[i,j],A[j,p])[],j=1..n)]; #Row(B,i).Column(A,p)
      end do
    end do;
    B:=C;
  end do;
  if not IsDirected(G) then # correct for double counting except for 2-cycles
        cycles:=map(i->i/2,cycles);
        if assigned(cycles[2]) then
            if cycles[2]=0 then # edgeless graphs
               evaln(cycles[2])
            else
               cycles[2]:=cycles[2]*2
            end if
        end if
  end if;
  eval(cycles);
end proc:

>

"G3:=CompleteGraph(5); cycles:=CycleCounts(G3): for i,cyc in eval(cycles) do i,cyc end do;add(eval(cycles)); "

>

memory used=138.66MiB, alloc change=0 bytes, cpu time=3.23s, real time=3.36s, gc time=156.25ms

>

Download ZeonsCycleCounts.mw

A linear algebra based version...

Answered: dharr 8205

June 21 2023

2 0

Smarter than Tarjan, perhaps, but slower:

>

Using the adjacency matrix and LinearAlgebra:-Generic to find cycles.

In this version, we use Arrays. In the modified adjacency matrix we just use and not .

>

Adj := AdjacencyMatrix(G); A := Matrix(n, n, proc (i, j) options operator, arrow; if Adj[i, j] = 1 then j else 0 end if end proc); B2 := Matrix(n, n, proc (i, j) options operator, arrow; if Adj[i, j] = 1 then {Array([i, j])} else {} end if end proc, datatype = set); B2, A

Matrix(%id = 36893489640244560108), Matrix(%id = 36893489640244559988)

Now we need to modify how we do matrix multiplication, but Maple has the LinearAlgebra:-Generic package to do this. We can redefine addition and multiplication to operate correctly on the sets of sets.

Consider two sets of sets of vertices for walks. WE ASSUME THE SECOND ONE HAS ONLY ONE VERTEX.

>

Addition is just combining the possibilities, and set union will do this. And addition of "zero" should add no possibilities, so we take {} as zero.

>

Multiplication is adjoining the extra vertex. But if the new is the same as an existing one we have intersected ourself, but not necessarily made a simple cycle. So we want to stop adding vertices by making the matrix entry {}. We can identify it as a cycle if it intersects the first vertex.

>	map((x,y)->if y in x then NULL else (Array(x),=y) end if,a,b);

The unit for multiplication should leave the set of sets unchanged, so {Array([])} can be used. (but never called)

>	map((x,y)->if y in x then NULL else (Array(x),=y) end if,{Array([])},b); map((x,y)->if y in x then NULL else (Array(x),=y) end if,a,{Array([])}[]); #needs special case

And we should check that zero multiplied by is zero

>	map((x,y)->if y in x then NULL else (Array(x),=y) end if,{},b); map((x,y)->if y in x then NULL else (Array(x),=y) end if,a,{}); #treat as special case

Define these operations for the LinearAlgebraGeneric package:

>

cycles := table(); m := 0; F[`=`] := `=`; F[`/`] := `/`; F[`0`] := {}; F[`1`] := 1; F[`+`] := `union`

>

F[`*`]:=(x, y) -> if y = 0 or y={} or x = {} then {}
                    elif y = {Array([])} then x
                    else map(proc(u, w);
                               if w in u then
                                  if w = u[1] and w = min(u) then cycles[k][u] := NULL end if;                                                     return NULL
                               else
                                  return (Array(u),=w)
                               end if;
                             end proc, x, y)
                    end if:

Warning, (in anonymous procedure within F[*]) `cycles` is implicitly declared local

>

Matrix(%id = 36893489716538042956)

>

Matrix(%id = 36893489716513642604)

>

So here is a procedure for the cycles in a graph - each cycle appears twice.

>

Cycles:=proc(G::Graph)
  uses GraphTheory;
  local x,y,k,u,w,A,B,F,n,cycles;
  #if IsDirected(G) then error "graph must be undirected" end if;
  cycles:=table();
  F[`=`]:=`=`:F[`/`]:=`/`: # not required but have to be specified
  F[`0`]:={}:
  F[`1`]:={Array([])}: # never used
  F[`+`]:=`union`:     # can get arguments in any order
  F[`*`]:=(x, y)       # x from left Matrix, y from right Matrix
                 -> if y = 0 or x = {} then {}
                    #elif y = {Array([])} then x
                    else map(proc(u, w);
                               if w in u then
                                  if w = u[1] and w = min(u) then cycles[k][u] := NULL end if;
                                  return NULL
                               else
                                  return (Array(u),=w)
                               end if;
                             end proc, x, y)
                    end if;
  n:=NumberOfVertices(G);
  A:=Matrix(n,n, (i, j)-> if AdjacencyMatrix(G)[i, j] = 1 then j else 0 end if);
  B:= Matrix(n,n, (i, j)-> if AdjacencyMatrix(G)[i, j] = 1 then {Array([i,j])} else {} end if);
  for k from 2 to n do
    B:=LinearAlgebra:-Generic:-MatrixMatrixMultiply[F](B,A);
  end do;
  cycles:=map({indices},cycles,'nolist');
  #cycles[2]:=evaln(cycles[2]); # if don't include 2-cycles
  eval(cycles);
end proc:

>

memory used=0.57GiB, alloc change=-32.00MiB, cpu time=5.88s, real time=4.94s, gc time=1.89s

>

Download GenericCyclesArraysVerticesOnly2.mw

Tarjan's algorithm...

Answered: dharr 8205

June 21 2023

1 2

I looked into this a while ago, and found Tarjan's backtracking algorithm is quite efficient, implementing the stack with Maple's DEQueue (not using the double ended feature). I just implemented it as stated; it may be able to be improved (perhaps the stack clearing). This doesn't use the cycle basis though.

Tarjan's algorithm for finding cycles. R. Tarjan, Enumeration of the Elementary Circuits of a Directed Graph, SIAM J. Comput. 2 (1973) 211. doi: 10.1137/0202017

Procedure Tarjan (in startup code) accepts a Graph and outputs a table with all cycles of a graph, indexed by the size of the cycles.
For an undirected graph each cycle except the 2-cycles appears twice, once in each orientation (clockwise or counterclockwise).

Cycles of a given size are in sets, with each cycle gives as an ordered list of vertices in the cycle, with the vertices numbered 1,..n, in the same order as Vertices(G). The lowest numbered vertex is first in the cycle.

For counting cycles without producing the cycles themselves use procedure TarjanCounts, which produces a table indexed by the cycle sizes giving counts of cycles of that size. This time, each cycle counts once; there is no double counting for undirected graphs.

>

restart;

>	with(GraphTheory):

>	G := AddVertex(PathGraph(5, directed), [6, 7]): AddArc(G, {[1, 3], [3, 7], [4, 6], [6, 7], [7, 1],[4,7]}); DrawGraph(G, layout = circle, size = [250, 250]);

Cycles broken down by lengths.

>	cycles:=Tarjan(G):

>	for i,cycle in eval(cycles) do i, cycle; end do;

Total number of cycles

>	add(map(nops,cycles));

>	counts:=TarjanCounts(G): for i,cycle in eval(counts) do i, cycle; end do; add(eval(counts));

>

memory used=90.10MiB, alloc change=32.00MiB, cpu time=1.81s, real time=1.82s, gc time=125.00ms

Numbers with different lengths.

>

The 16 cycles of length 15

>

This version just counts cycles, and doesn't output them.

>

memory used=53.73MiB, alloc change=0 bytes, cpu time=812.00ms, real time=815.00ms, gc time=0ns

>

"for i,cycle in eval(counts) do i, cycle; end do; add(eval(counts)); "

>

Download Tarjan.mw

Code in startup code reproduced here (version that just counts is also there).

# Tarjan outputs a table with all cycles of a graph, indexed by the size of the cycles
# for an undirected graph each cycle except the 2-cycles appears twice, once for each orientation.
Tarjan:=proc(G::GRAPHLN);
  local V,AA,backtrack,cycles,marked_stack,point_stack,mark,A,u,i;
#  
  backtrack:=proc(s,v)
    local f,u,w,g;
    f:=false;
    push_back(point_stack,v);
    mark[v]:=true;
    push_back(marked_stack,v);
    for w in A[v] do
      if w<s then
        A[v]:=A[v] minus {w};
      elif w=s then
        cycles[numelems(point_stack)][convert(point_stack,list)]:=NULL; #record cycle
        f:=true;
      elif not mark[w] then
        g:=procname(s,w);
        f:=f or g;
      end if; 
    end do;
    if f then
      while back(marked_stack)<>v do
        u:=pop_back(marked_stack);
        mark[u]:=false
      end do;
      pop_back(marked_stack);
      mark[v]:=false;
    end if;
    pop_back(point_stack);
    return f;
  end proc:
#
  V:=GraphTheory:-NumberOfVertices(G):
  AA:=op(4,G):
  cycles:=table():
  marked_stack:=DEQueue():
  point_stack:=DEQueue():
  mark:=Vector(V,'fill'=false): 
  for i to V do
    A:=copy(AA);
    backtrack(i,i);
    while not empty(marked_stack) do
      u:=pop_back(marked_stack);
      mark[u]:=false;
    end do;
  end do;
  map({indices},cycles,'nolist');
end proc;

Need an accurate initial point to use hi...

Answered: dharr 8205

June 17 2023

2 3

>

restart;

>	fun:=(2(x+y+z)(sqrt(yz(z+x)(x+y))/(z+2x+y\ )+sqrt(zx(x+y)(y+z))/(x+2y+z)+sqrt(xy(y+z)(z+x))/(y\ +2z+x))-(9xyz/(x+y+z)+2(yz+zx+xy)))/(sqrt(xyz/(x+y+z))(x+y+z-sqrt(27xy*z/(x+y+z))));

(2*(x+y+z)*((y*z*(z+x)*(x+y))^(1/2)/(z+2*x+y)+(z*x*(x+y)*(y+z))^(1/2)/(x+2*y+z)+(x*y*(y+z)*(z+x))^(1/2)/(y+2*z+x))-9*x*y*z/(x+y+z)-2*x*y-2*z*x-2*y*z)/((x*y*z/(x+y+z))^(1/2)*(x+y+z-3*3^(1/2)*(x*y*z/(x+y+z))^(1/2)))

Apply a mix of the strategies of @mmcdara and @Axel Vogt
If we scale each variable by a, we do not change the value of fun.

>	simplify(eval(fun,{x=ax,y=ay,z=a*z})-fun) assuming a>0;

So we can arbitrarily set x=1, and reduce it to a to two-variable problem a la @mmcdara

>	f2:=eval(fun,x=1);

(2*(1+y+z)*((y*z*(z+1)*(1+y))^(1/2)/(z+2+y)+(z*(1+y)*(y+z))^(1/2)/(1+2*y+z)+(y*(y+z)*(z+1))^(1/2)/(y+2*z+1))-9*y*z/(1+y+z)-2*y-2*z-2*y*z)/((y*z/(1+y+z))^(1/2)*(1+y+z-3*3^(1/2)*(y*z/(1+y+z))^(1/2)))

As @Axel Vogt noted if we take z=1/y we achieve the alleged maximim at y=0 and y=infinity, suggesting we want y=0 and z=infinity or vice versa

>	f3:=eval(f2,z=1/y):plot(f3,y=0..infinity);

>	limit(f3,y=0,right);limit(f3,y=infinity);

So we take this as the initialpoint and see how well we will do

>	Optimization:-Maximize(f2, assume = nonnegative, initialpoint=[y=0,z=infinity]);

Error, (in Optimization:-NLPSolve) no improved point could be found

Well if we trust this, we have hit the jackpot. But let's try some values slightly off. The large z is unchanged

>	Optimization:-Maximize(f2, assume = nonnegative, initialpoint=[y=0.011,z=1e99]);

Any smaller y leads to

>	Optimization:-Maximize(f2, assume = nonnegative, initialpoint=[y=0.010,z=1e99]);

Error, (in Optimization:-NLPSolve) no improved point could be found

This calculation is apparently done with the NAG routines (From the package overview help: "The package takes advantage of built-in library routines provided by the Numerical Algorithms Group (NAG)"), which I took to mean it was done at hardware precision. Therefore I was expecting it to not to improve once Digits was higher than the evalhf(Digits) value (here 15). But it does seem possible now we are close to the right answer:

>	interface(warnlevel=0): #suppress "Warning, undefined value encountered" Digits:=200:Optimization:-Maximize(f2, assume = nonnegative, initialpoint=[y=0.011,z=1e99]);

>

Download maximize.mw

not all x,y,z,w give solutions...

Answered: dharr 8205

June 15 2023

1 0

>

eq := a+b+c = n*x; eq2 := a+3*b+c = n*y; eq3 := a+b+5*c = n*z; eq4 := 4*a+8*b = n*w

>

Matrix(%id = 36893489914357921060), Vector[column](%id = 36893489914357920940)

Consider the case used by @tomleslie

>

Matrix(%id = 36893489914357910812)

Since the Rank is 3, there is an infinite set of one-parameter solutions, as @tomleslie found from isolve, and they are integer

>

Vector[column](%id = 36893489914357963100)

If the rank is 4 then the only solution will be a=b=c=n=0., which doesn't have n positive.

So the only sets of {w,x,y,z} that have solutions (integer or otherwise) will be those that make the last column a linear combination of the other 3 columns. The solutions are then the coefficients of the linear combination. For example we can add the columns

>

Matrix(%id = 36893489914345976044)

and so the solution is (by construction) {a=b=c=n=1} or any multiple of this.

>

Vector[column](%id = 36893489914345981340)

>

Download LinearSystem.mw

one way...

Answered: dharr 8205

June 12 2023

1 0

Here's one way.

Download cis.mw

Heaviside or piecewise...

Answered: dharr 8205

June 07 2023

1 1

Here are two suggestions.

Download Heaviside.mw

slightly different...

Answered: dharr 8205

June 03 2023

0 2

For me (2023.0, Windows 10), the second one hangs, but if I use the stop icon (after 250 s) it quickly ends and prints "done", and then I can continue to use Maple as normally.

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

8205 Reputation

22 Badges

Social Networks and Content at Maplesoft.com

MaplePrimes Activity

These are answers submitted by dharr

something...

Can be positive semidefinite...

datasetlabels = contents...

Functorial composition in combstruct...

improved labels...

dchange...

integers but not very random...

Zeon algebra...

A linear algebra based version...

Tarjan's algorithm...

Need an accurate initial point to use hi...

not all x,y,z,w give solutions...

one way...

Heaviside or piecewise...

slightly different...

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