Help:=proc():
print(`Cube,AddCube,AddCube1,RandCube, RandCube1, AddManyCubes`):
print(`MultCube,StackCube,PCube,PowerCubes,OddParts,PowerCubeSym`):
end:


Cube:=proc(n,x) local L,i,j,k;
	for i from 1 to n do
		for j from 1 to n do
			for k from 1 to n do
				L[i][j][k]:=x[i,j,k]:
			od:
		od:
	od:
[seq([seq([seq(L[i][j][k],k=1..n)],j=1..n)],i=1..n)]:
end:

####################################################

AddCube:=proc(A,B) local i, j, k, C,n:

if nops(A)<>nops(B) then
	print(`To add : Two hypermatrices need to have the same dimension`):
	RETURN(FAIL):
fi:

n:=nops(A):

C:=[seq([seq([seq(C[i][j][k],k=1..n)],j=1..n)],i=1..n)]:

	for i from 1 to n do
		for j from 1 to n do
			for k from 1 to n do
				C[i][j][k]:=A[i][j][k]+B[i][j][k]:	
			od:
		od:
	od:
C:
end:
##################################################

AddCube1:=proc(A,B) local i, j, k, C,n:

if nops(A)<>nops(B) then
	print(`Two hypermatrices need to have the same dimension`):
	RETURN(FAIL):
fi:

n:=nops(A):

C:=[seq([seq([seq(A[i][j][k]+B[i][j][k],k=1..n)],j=1..n)],i=1..n)]:

end:

#################################################


RandCube1:=proc(n,N) local L,i,j,k,ra;

L:=[seq([seq([seq(L[i][j][k],k=1..n)],j=1..n)],i=1..n)]:

ra:=rand(N):
	for i from 1 to n do
		for j from 1 to n do
			for k from 1 to n do
				L[i][j][k]:=ra():
			od:
		od:
	od:

L:
end:
##################################################
RandCube:=proc(n,N) local L,i,j,k,ra;

ra:=rand(N):

L:=[seq([seq([seq(ra(),k=1..n)],j=1..n)],i=1..n)]:

end:
##################################################

AddManyCubes:=proc(L) local i,k,C,n:

k:=nops(L):
n:=nops(L[1]):

C:=[seq([seq([seq(0,k=1..n)],j=1..n)],i=1..n)]:
for i from 1 to k do
	C:=AddCube(C,L[i]):
od:
end:

###################################################

MultCube:=proc(A,B,C) local i,j,k,t,M,n:

n:=nops(A) :

M:=[seq([seq([seq(add(A[i][t][k]*B[i][j][t]*C[t][j][k],t=1..n),k=1..n)],j=1..n)],i=1..n)]:

end:

###################################################

StackCube:=proc(A) local i,j,k,l,m,n,L:

m:=nops(A):
n:=(m)^3:
L:=[seq(seq(seq([A[i][j][k]],i=1..m),j=1..m),k=1..m)]:

end:
####################################################

########################################

with(combinat):

PCube:=proc(n) local L,L1,L2,L3,i,m,j,k,z,w:

L:=partition(n):
m:=nops(L):
L1:=[]:
L2:=[]:
L3:=[]:
for i from 1 to m do
	if nops(L[i])=3 then 
			L1:=[op(L1),L[i]]:
	
	fi:
od:

for j from 1 to nops(L1) do
	if (L1[j][1] mod 2)=1 and (L1[j][2] mod 2)=1 and (L1[j][3] mod 2)=1 then
		L2:=[op(L2),L1[j]]:
	fi:
od:

for k from 1 to nops(L2) do
	L3:=[op(L3),op(permute(L2[k]))]:
od:

L3:

end:

########################################
PowerCubes:=proc(A,n) local i,j,k,t,m,h,v,L,Pseq,L1,z,P:
option remember:

if (n mod 2) = 0 then
	print(`We can't perform power operation with this number of cubes. The number of hypercube has to be odd`):
	RETURN(FAIL):
fi:
if n=1 then 
	RETURN([A]):
	fi:
if n=3 then		
	RETURN(MultCube(A,A,A)):
fi:

k:= (n+1)/2:
L[1]:=[A]:
L[2]:=[MultCube(A,A,A)]: 

for t from 3 to k do

	L[t]:=[]

od:

for i from 3 to k do

	P:=PCube(2*i-1):
	for j from 1 to nops(P) do	

		for m from 1 to (nops(L[(P[j][1]+1)/2])) do
			for h from 1 to nops(L[(P[j][2]+1)/2]) do
				for v from 1 to nops(L[(P[j][3]+1)/2]) do
					L[i]:=[op(L[i]),MultCube(L[(P[j][1]+1)/2][m],L[(P[j][2]+1)/2][h],L[(P[j][3]+1)/2][v])]:
				od:
			od:
		od:
				
	od:
	
od:
	
L[k]:
end:


#############################################

TripleA:=proc() local A : 
[[A,A,A]] : 
end : 

#################################################


#powers of A with N operands 
PowerCubeSym:=proc(N)   local A,L,K,v,i,M,j,w,s,z  : 
option remember : 

if N mod 2 =0 then
    print(`N must be an odd integer`) : 
	RETURN(FAIL) : 
fi : 


L[1]:=[A] : 
L[2]:=TripleA(): 

if n=1 then 
	RETURN(L[1]):
	fi:
if n=3 then		
	RETURN(L[2]):
fi:
K:=(N+1)/2 : 


for v from 3 to K do 
   L[v]:=[] : 
od : 

for i from 3 to K do 
   M:=PCube(2*i-1) : 
  
   for j from 1 to nops(M) do 
	
	     for w from 1 to nops(L[(M[j][1]+1)/2]) do 
	
			for s from 1 to nops(L[(M[j][2]+1)/2]) do
			
			     for z from 1 to nops(L[(M[j][3]+1)/2]) do
					
					
		            L[i]:=[op(L[i]),[L[(M[j][1]+1)/2][w],L[(M[j][2]+1)/2][s],L[(M[j][3]+1)/2][z]]]:
					
					
					 
			     od : 
		    od : 
	    od : 
	od : 
od : 
	
L[K] : 
end :