Codigo fuente sonar3d

Costas.py

@@ -0,0 +1,368 @@
+
+class Costas:
+
+	def __init__(self):
+		pass
+
+
+	def BuildWelch(self, p, root):
+		costas = [0] * (p-1)
+		for i in range(p-1):
+			costas[i] = pow(root, i+1) % p 
+		return costas
+
+	def isCostas(self, array):
+		a_size = len(array)
+		for c in range(1, a_size):
+			hash = [0] * (2 * a_size)
+			for i in range(a_size - c):
+				dif = array[i+c] - array[i]
+				#print dif,
+				if hash[dif] == 1:
+					return 0
+				else:
+					hash[dif] = 1
+			#print
+		return 1
+
+        def CostasExtendedCrossCorrelation(self, costa1, costa2, n):
+                cross = 0
+                for h in range(n):
+                	hash = [0] * (n - 1)
+                        for i in range(n):
+                        	if costa1[(i+h) % n] == "*" or costa2[i] == "*":
+                                	 continue
+                             	dif =  (costa1[(i + h) % n] - costa2[i]) % (n- 1)
+                             	hash[dif]+=1
+                               	if cross < hash[dif]:
+                                	cross = hash[dif]
+                return cross
+
+
+	def isExtendedCostas(self, costas, n):
+		for h in range(n):
+			if h == 0:
+				continue
+			hash = [0] * (n-1)
+			for i in range(n):
+				if costas[(i + h) % n] == "*" or costas[i] == "*":
+					continue
+				dif = (costas[(i+h) % n] - costas[i]) % (n-1)
+				if hash[dif] == 1:
+					return 0
+				else:
+					hash[dif] = 1
+		return 1
+
+        def CostasColumnSymetries(self, a, p):
+                costaList = []
+                for i in range(2, p):
+                        costas = [0] * p
+                        for x in range(p):
+                       		costas[(x*i) % p] = a[x]
+                        costaList.append(costas)
+                return costaList
+
+
+
+        def is3DCostas(self, costas, n):                
+		for h1 in range(n):
+                        for h2 in range(n):
+                                if h1 == 0 and h2 == 0:
+                                        continue
+                                hash = [0] * ((n*n) - 1)
+                                for i in range(n):
+                                        for j in range(n):                                       
+                                                #if i == 0 and j == 0:
+                                                #        continue
+                                                #if (i+h1) % n == 0 and (j+h2) % n == 0:
+						# Fix for * anyware on the grid.
+						if costas[(i+h1) % n][(j+h2) % n] == "*" or costas[i][j] == "*":
+                                                        continue
+
+                                                dif =  (costas[((i + h1) % n)][((j+h2) % n)]
+ - costas[i][j]) % (pow(n,2) - 1)
+                                                #print dif,
+                                                if hash[dif] == 1:
+                                                        return 0
+                                                else:
+                                                        hash[dif] =1
+                                #print
+                return 1
+
+	def Costas3DCrossCorrelation(self, costa1, costa2, n):
+		cross = 0
+		for h1 in range(n):
+                        for h2 in range(n):
+                                #if h1 == 0 and h2 == 0:
+                                #        continue
+                                hash = [0] * ((n*n) - 1)
+                                for i in range(n):
+                                        for j in range(n):                                       
+                                                #if i == 0 and j == 0:
+                                                #        continue
+                                                #if (i+h1) % n == 0 and (j+h2) % n == 0:
+                                        	# Fix for * anyware on the grid.
+                                                if costa1[(i+h1) % n][(j+h2) % n] == "*" or costa2[i][j] == "*": 
+						       continue
+
+                                                dif =  (costa1[((i + h1) % n)][((j+h2) % n)]
+ - costa2[i][j]) % (pow(n,2) - 1)
+                                                #print dif,
+                                                hash[dif]+=1
+						if cross < hash[dif]:
+							cross = hash[dif]
+                                #print
+				#print hash
+                return cross
+
+		
+
+	def is3DCostas1D(self, costas, n):
+	        for h1 in range(n):
+       	        	for h2 in range(n):
+       	                	if h1 == 0 and h2 == 0:
+                                	continue
+                        	hash = [0] * ((n*n) - 1)
+                        	for i in range(n):
+                                	for j in range(n):                                        
+						if i == 0 and j == 0:
+                                                	continue
+                                        	if (i+h1) % n == 0 and (j+h2) % n == 0:
+                                                	continue
+
+                                        	dif =  (costas[ n *((i + h1) % n) + ((j+h2) % n)] - costas[n*i+j]) % (pow(n,2) - 1)
+						#print dif,
+                                        	if hash[dif] == 1:
+                                                	return 0
+                                        	else:
+                                                	hash[dif] =1
+				#print	
+        	return 1
+		
+	def Costas3DRowSymetries(self, a, p):
+		# Given a Welch 3dCostas return all its column symetries 
+		costaList = []
+		for i in range(2,p):
+        		costas2d = []
+                        for j in range(p):
+                                costas2d.append([0] * p)
+                        for x in range(p):
+                                for y in range(p):
+                                        if x == 0 and y == 0:
+                                                costas2d[x][y] = "*"
+                                        else:
+                                                costas2d[(x*i) % p][y] = a[x][y]
+
+        		costaList.append(costas2d)
+		return costaList
+	
+	def Costas3DRowShiftPermutation(self, a, p):
+		# Given a Welch 3dCostas return all its row power permutations
+                costaList = []
+                for i in range(1,p):
+                        costas2d = []
+                        costas2d.append(a[0][:])
+                        for j in range(1, p):
+                                costas2d.append(a[j][-(((i*j)%p)) :] + a[j][:-((i*j)%p)])
+                        costaList.append(costas2d)
+                return costaList
+
+	
+	def Costas3DColumnSymetries(self, a, p):
+		costaList = []
+		for i in range(2, p):
+			costas2d = []
+			for j in range(p):
+				costas2d.append([0] * p)
+			for y in range(p):
+				for x in range(p):
+					if x == 0 and y == 0:
+						costas2d[x][y] = "*"
+					else:
+						costas2d[x][(y*i) % p] = a[x][y]
+			costaList.append(costas2d)
+		return costaList	
+
+        def Costas3DColumnShiftPermutation(self, a, p):
+                costaList = []
+                for i in range(1, p):
+                        costas2d = []
+                        for j in range(p):
+                                costas2d.append([0] * p)
+                        for y in range(p):
+                                for x in range(p):
+                                        if x == 0 and y == 0:
+                                                costas2d[x][y] = "*"
+                                        else:
+                                                costas2d[(x+(y*i)) % p][y] = a[x][y]
+                        costaList.append(costas2d)
+                return costaList
+	
+	def CostasAdditionSymetries(self, a, p):
+		#Given a Welch 3dCostas return all its Addition symetries excluding a
+		costaList = []
+		for i in range(1, p):
+			costas2d = []
+			for j in range(p):
+				costas2d.append([0] * p)
+			for x in range(p):
+				for y in range(p):
+					if x == 0 and y == 0:
+						costas2d[x][y] = "*"
+					else:
+						costas2d[x][y] = (a[x][y] + i) % (pow(p,2)-1)
+			costaList.append(costas2d)
+
+		return costaList
+			
+	def CostasMultiplicationSymetries(self, a, p1, primes):
+		costaList = []
+		for p in primes:
+			costas2d = []
+                        for j in range(p1):
+                                costas2d.append([0] * p1)
+
+			for x in range(p1):
+				for y in range(p1):
+					if x == 0 and y == 0:
+						costas2d[0][0] = "*"
+					else:
+						costas2d[x][y] = (a[x][y] * p) % (pow(p1,2)-1)	
+			costaList.append(costas2d)
+		return costaList
+
+	def Costas3D90DegreeSymetry(self, a, p):
+		# Given a Welch 3DCostas return its 90Degree Symetry
+		costas = [] * p
+		for i in range(p):
+			costas.append([0] * p)
+		for i in range(p):
+			for j in range(p):
+				costas[i][j] = a[j][i]
+				
+		return costas
+
+	def Costas3DDihedralSymetry(self, a, p):
+		costas = [] * p
+                for i in range(p):
+                        costas.append([0] * p)
+		for i in range(p):
+			costas[i] = a[i][:]
+			costas[i].reverse()
+		return costas
+	
+	def Costas2Legendre(self, a, p):
+		for i in range(p):
+			for j in range(p):
+				if a[i][j] == "*":
+					continue
+				if(a[i][j] % 2 == 0):
+					a[i][j]=1
+				else:
+					a[i][j]=-1
+		
+	def GetLegendre(self, a, p):
+                # Given a Welch 3DCostas return its Legendre
+                costas = [] * p
+                for i in range(p):
+                        costas.append([0] * p)
+
+                for i in range(p):
+                        for j in range(p):
+                                if a[i][j] == "*":
+					costas[i][j] = "*"
+                                        continue
+
+                                if(a[i][j] % 2 == 0):
+                                        costas[i][j]=1
+                                else:
+                                        costas[i][j]=-1
+		return costas
+	
+	def IsCalabro(self, a, p):
+		# Check if Legendre array is Calabro
+		similar = (p-1)/2
+		counter = [0] * p	
+		for i in range(1, p-1):
+			for j in range(i+1, p):
+				if a[i] == a[j]:
+					if counter[i] == 0:
+						counter[i]+=2
+					else:
+						counter[i]+=1
+					if counter[j] == 0:
+						counter[j]+=2
+					else:
+						counter[j]+=1
+		if similar in counter:
+			return 1, counter
+		else:
+			return 0, counter
+
+	def LegendreCorrelation(self, legendre, p):
+		cor = 0
+		cor_pos = 0
+		cor_neg = 0
+		for h1 in range(p):
+			for h2 in range(p):
+				if h1 == 0 and h2 == 0:
+					continue
+				tmp_cor = 0
+				for i in range(p):
+					for j in range(p):
+						tmp_cor += legendre[(i + h1) % p][(j + h2) % p] * legendre[i][j]
+				
+				if tmp_cor < 0:
+					if tmp_cor < cor_neg:
+						cor_neg = tmp_cor					
+				else:
+					if tmp_cor > cor_pos:
+						cor_pos = tmp_cor
+				if abs(tmp_cor) > cor:
+					cor = abs(tmp_cor) 	
+		return cor, cor_neg, cor_pos
+				
+        def LegendreCrossCorrelation(self, legendre1, legendre2, p):
+                cor = 0
+                cor_pos = 0
+                cor_neg = 0
+                for h1 in range(p):
+                        for h2 in range(p):
+                                #if h1 == 0 and h2 == 0:
+                                #        continue
+                                tmp_cor = 0
+                                for i in range(p):
+                                        for j in range(p):
+                                                if legendre1[(i + h1) % p][(j + h2) % p] == "*" or legendre2[i][j] == "*":
+                                                        continue
+                                                tmp_cor += legendre1[(i + h1) % p][(j + h2) % p] * legendre2[i][j]
+
+                                if tmp_cor < 0:
+                                        if tmp_cor < cor_neg:
+                                                cor_neg = tmp_cor
+                                else:
+                                        if tmp_cor > cor_pos:
+                                                cor_pos = tmp_cor
+                                if abs(tmp_cor) > cor:
+                                        cor = abs(tmp_cor)
+                return cor, cor_neg, cor_pos
+
+
+	def LegendreCrossCorrelationCoincidences(self, legendre1, legendre2, p):
+                cor = 0
+                for h1 in range(p):
+                        for h2 in range(p):
+                                #if h1 == 0 and h2 == 0:
+                                #        continue
+                                tmp_cor = 0
+                                for i in range(p):
+                                        for j in range(p):
+                                                if legendre1[(i + h1) % p][(j + h2) % p] == legendre2[i][j]:
+							tmp_cor+=1 
+                                if tmp_cor > cor:
+                                        cor = tmp_cor
+                return cor
+		
+#c = Costas()
+#print c.isCostas([4,3,2,1])	

Makefile

@@ -0,0 +1,2 @@
+all:
+	g++ -o sonar3dnxn sonar3dnxn.cpp

Sonar.py

@@ -0,0 +1,395 @@
+
+class Sonar:
+
+	def __init__(self):
+		pass
+
+
+	def BuildWelch(self, p, root):
+		costas = [0] * (p-1)
+		for i in range(p-1):
+			costas[i] = pow(root, i+1) % p 
+		return costas
+
+	def isCostas(self, array):
+		a_size = len(array)
+		for c in range(1, a_size):
+			hash = [0] * (2 * a_size)
+			for i in range(a_size - c):
+				dif = array[i+c] - array[i]
+				#print dif,
+				if hash[dif] == 1:
+					return 0
+				else:
+					hash[dif] = 1
+			#print
+		return 1
+
+        def CostasExtendedCrossCorrelation(self, costa1, costa2, n):
+                cross = 0
+                for h in range(n):
+                	hash = [0] * (n - 1)
+                        for i in range(n):
+                        	if costa1[(i+h) % n] == "*" or costa2[i] == "*":
+                                	 continue
+                             	dif =  (costa1[(i + h) % n] - costa2[i]) % (n- 1)
+                             	hash[dif]+=1
+                               	if cross < hash[dif]:
+                                	cross = hash[dif]
+                return cross
+
+
+	def isExtendedCostas(self, costas, n):
+		for h in range(n):
+			if h == 0:
+				continue
+			hash = [0] * (n-1)
+			for i in range(n):
+				if costas[(i + h) % n] == "*" or costas[i] == "*":
+					continue
+				dif = (costas[(i+h) % n] - costas[i]) % (n-1)
+				if hash[dif] == 1:
+					return 0
+				else:
+					hash[dif] = 1
+		return 1
+
+        def CostasColumnSymetries(self, a, p):
+                costaList = []
+                for i in range(2, p):
+                        costas = [0] * p
+                        for x in range(p):
+                       		costas[(x*i) % p] = a[x]
+                        costaList.append(costas)
+                return costaList
+
+
+
+        def is3DCostas(self, costas, n):                
+		for h1 in range(n):
+                        for h2 in range(n):
+                                if h1 == 0 and h2 == 0:
+                                        continue
+                                hash = [0] * ((n*n) - 1)
+                                for i in range(n):
+                                        for j in range(n):                                       
+                                                #if i == 0 and j == 0:
+                                                #        continue
+                                                #if (i+h1) % n == 0 and (j+h2) % n == 0:
+						# Fix for * anyware on the grid.
+						if costas[(i+h1) % n][(j+h2) % n] == "*" or costas[i][j] == "*":
+                                                        continue
+
+                                                dif =  (costas[((i + h1) % n)][((j+h2) % n)]
+ - costas[i][j]) % (pow(n,2) - 1)
+                                                #print dif,
+                                                if hash[dif] == 1:
+                                                        return 0
+                                                else:
+                                                        hash[dif] =1
+                                #print
+                return 1
+
+	def Costas3DCrossCorrelation(self, costa1, costa2, n):
+		cross = 0
+		for h1 in range(n):
+                        for h2 in range(n):
+                                #if h1 == 0 and h2 == 0:
+                                #        continue
+                                hash = [0] * ((n*n) - 1)
+                                for i in range(n):
+                                        for j in range(n):                                       
+                                                #if i == 0 and j == 0:
+                                                #        continue
+                                                #if (i+h1) % n == 0 and (j+h2) % n == 0:
+                                        	# Fix for * anyware on the grid.
+                                                if costa1[(i+h1) % n][(j+h2) % n] == "*" or costa2[i][j] == "*": 
+						       continue
+
+                                                dif =  (costa1[((i + h1) % n)][((j+h2) % n)]
+ - costa2[i][j]) % (pow(n,2) - 1)
+                                                #print dif,
+                                                hash[dif]+=1
+						if cross < hash[dif]:
+							cross = hash[dif]
+                                #print
+				#print hash
+                return cross
+
+		
+
+	def is3DSonar1D(self, costas, p, n):
+	        for h1 in range(p):
+       	        	for h2 in range(p):
+       	                	if h1 == 0 and h2 == 0:
+                                	continue
+                        	hash = [0] * ((p*p))
+                        	for i in range(p):
+					if p*i > n-1:
+						break
+                                	for j in range(p):                                        
+						if i == 0 and j == 0:
+                                                	continue
+                                        	if (i+h1) % p == 0 and (j+h2) % p == 0:
+                                                	continue
+							
+						if p*i+j > n-1:
+							break
+
+						if  p *((i + h1) % p) + ((j+h2) % p) > n - 1:
+							continue
+
+                                        	dif =  (costas[ p *((i + h1) % p) + ((j+h2) % p)] - costas[p*i+j]) % (pow(p,2))
+                                        	if hash[dif] == 1:
+                                                	return 0
+                                        	else:
+                                                	hash[dif] =1
+				#print	
+        	return 1
+
+        def is3DSonar1DFull(self, costas, p):
+                for h1 in range(p):
+                        for h2 in range(p):
+                                if h1 == 0 and h2 == 0:
+                                        continue
+                                hash = [0] * (p*p)
+                                for i in range(p):
+                                        for j in range(p):
+                                                if i == 0 and j == 0:
+                                                        continue
+                                                if (i+h1) % p == 0 and (j+h2) % p == 0:
+                                                        continue
+                                                dif =  (costas[ p *((i + h1) % p) + ((j+h2) % p)] - costas[p*i+j]) % (pow(p,2))
+                                                #print dif,
+                                                if hash[dif] == 1:
+                                                        return 0
+                                                else:
+                                                        hash[dif] =1
+		return 1
+		
+	def Costas3DRowSymetries(self, a, p):
+		# Given a Welch 3dCostas return all its column symetries 
+		costaList = []
+		for i in range(2,p):
+        		costas2d = []
+                        for j in range(p):
+                                costas2d.append([0] * p)
+                        for x in range(p):
+                                for y in range(p):
+                                        if x == 0 and y == 0:
+                                                costas2d[x][y] = "*"
+                                        else:
+                                                costas2d[(x*i) % p][y] = a[x][y]
+
+        		costaList.append(costas2d)
+		return costaList
+	
+	def Costas3DRowShiftPermutation(self, a, p):
+		# Given a Welch 3dCostas return all its row power permutations
+                costaList = []
+                for i in range(1,p):
+                        costas2d = []
+                        costas2d.append(a[0][:])
+                        for j in range(1, p):
+                                costas2d.append(a[j][-(((i*j)%p)) :] + a[j][:-((i*j)%p)])
+                        costaList.append(costas2d)
+                return costaList
+
+	
+	def Costas3DColumnSymetries(self, a, p):
+		costaList = []
+		for i in range(2, p):
+			costas2d = []
+			for j in range(p):
+				costas2d.append([0] * p)
+			for y in range(p):
+				for x in range(p):
+					if x == 0 and y == 0:
+						costas2d[x][y] = "*"
+					else:
+						costas2d[x][(y*i) % p] = a[x][y]
+			costaList.append(costas2d)
+		return costaList	
+
+        def Costas3DColumnShiftPermutation(self, a, p):
+                costaList = []
+                for i in range(1, p):
+                        costas2d = []
+                        for j in range(p):
+                                costas2d.append([0] * p)
+                        for y in range(p):
+                                for x in range(p):
+                                        if x == 0 and y == 0:
+                                                costas2d[x][y] = "*"
+                                        else:
+                                                costas2d[(x+(y*i)) % p][y] = a[x][y]
+                        costaList.append(costas2d)
+                return costaList
+	
+	def CostasAdditionSymetries(self, a, p):
+		#Given a Welch 3dCostas return all its Addition symetries excluding a
+		costaList = []
+		for i in range(1, p):
+			costas2d = []
+			for j in range(p):
+				costas2d.append([0] * p)
+			for x in range(p):
+				for y in range(p):
+					if x == 0 and y == 0:
+						costas2d[x][y] = "*"
+					else:
+						costas2d[x][y] = (a[x][y] + i) % (pow(p,2)-1)
+			costaList.append(costas2d)
+
+		return costaList
+			
+	def CostasMultiplicationSymetries(self, a, p1, primes):
+		costaList = []
+		for p in primes:
+			costas2d = []
+                        for j in range(p1):
+                                costas2d.append([0] * p1)
+
+			for x in range(p1):
+				for y in range(p1):
+					if x == 0 and y == 0:
+						costas2d[0][0] = "*"
+					else:
+						costas2d[x][y] = (a[x][y] * p) % (pow(p1,2)-1)	
+			costaList.append(costas2d)
+		return costaList
+
+	def Costas3D90DegreeSymetry(self, a, p):
+		# Given a Welch 3DCostas return its 90Degree Symetry
+		costas = [] * p
+		for i in range(p):
+			costas.append([0] * p)
+		for i in range(p):
+			for j in range(p):
+				costas[i][j] = a[j][i]
+				
+		return costas
+
+	def Costas3DDihedralSymetry(self, a, p):
+		costas = [] * p
+                for i in range(p):
+                        costas.append([0] * p)
+		for i in range(p):
+			costas[i] = a[i][:]
+			costas[i].reverse()
+		return costas
+	
+	def Costas2Legendre(self, a, p):
+		for i in range(p):
+			for j in range(p):
+				if a[i][j] == "*":
+					continue
+				if(a[i][j] % 2 == 0):
+					a[i][j]=1
+				else:
+					a[i][j]=-1
+		
+	def GetLegendre(self, a, p):
+                # Given a Welch 3DCostas return its Legendre
+                costas = [] * p
+                for i in range(p):
+                        costas.append([0] * p)
+
+                for i in range(p):
+                        for j in range(p):
+                                if a[i][j] == "*":
+					costas[i][j] = "*"
+                                        continue
+
+                                if(a[i][j] % 2 == 0):
+                                        costas[i][j]=1
+                                else:
+                                        costas[i][j]=-1
+		return costas
+	
+	def IsCalabro(self, a, p):
+		# Check if Legendre array is Calabro
+		similar = (p-1)/2
+		counter = [0] * p	
+		for i in range(1, p-1):
+			for j in range(i+1, p):
+				if a[i] == a[j]:
+					if counter[i] == 0:
+						counter[i]+=2
+					else:
+						counter[i]+=1
+					if counter[j] == 0:
+						counter[j]+=2
+					else:
+						counter[j]+=1
+		if similar in counter:
+			return 1, counter
+		else:
+			return 0, counter
+
+	def LegendreCorrelation(self, legendre, p):
+		cor = 0
+		cor_pos = 0
+		cor_neg = 0
+		for h1 in range(p):
+			for h2 in range(p):
+				if h1 == 0 and h2 == 0:
+					continue
+				tmp_cor = 0
+				for i in range(p):
+					for j in range(p):
+						tmp_cor += legendre[(i + h1) % p][(j + h2) % p] * legendre[i][j]
+				
+				if tmp_cor < 0:
+					if tmp_cor < cor_neg:
+						cor_neg = tmp_cor					
+				else:
+					if tmp_cor > cor_pos:
+						cor_pos = tmp_cor
+				if abs(tmp_cor) > cor:
+					cor = abs(tmp_cor) 	
+		return cor, cor_neg, cor_pos
+				
+        def LegendreCrossCorrelation(self, legendre1, legendre2, p):
+                cor = 0
+                cor_pos = 0
+                cor_neg = 0
+                for h1 in range(p):
+                        for h2 in range(p):
+                                #if h1 == 0 and h2 == 0:
+                                #        continue
+                                tmp_cor = 0
+                                for i in range(p):
+                                        for j in range(p):
+                                                if legendre1[(i + h1) % p][(j + h2) % p] == "*" or legendre2[i][j] == "*":
+                                                        continue
+                                                tmp_cor += legendre1[(i + h1) % p][(j + h2) % p] * legendre2[i][j]
+
+                                if tmp_cor < 0:
+                                        if tmp_cor < cor_neg:
+                                                cor_neg = tmp_cor
+                                else:
+                                        if tmp_cor > cor_pos:
+                                                cor_pos = tmp_cor
+                                if abs(tmp_cor) > cor:
+                                        cor = abs(tmp_cor)
+                return cor, cor_neg, cor_pos
+
+
+	def LegendreCrossCorrelationCoincidences(self, legendre1, legendre2, p):
+                cor = 0
+                for h1 in range(p):
+                        for h2 in range(p):
+                                #if h1 == 0 and h2 == 0:
+                                #        continue
+                                tmp_cor = 0
+                                for i in range(p):
+                                        for j in range(p):
+                                                if legendre1[(i + h1) % p][(j + h2) % p] == legendre2[i][j]:
+							tmp_cor+=1 
+                                if tmp_cor > cor:
+                                        cor = tmp_cor
+                return cor
+		
+#c = Costas()
+#print c.isCostas([4,3,2,1])	

issonar.py

@@ -0,0 +1,8 @@
+from Sonar import *
+
+p = 3
+sonar = ["*", 1, 1, 1, 2, 5, 4, 8, 5]
+
+s = Sonar()
+if s.is3DSonar1DFull(sonar, p):
+	print "Sonar"

sonar3d.cpp

@@ -0,0 +1,97 @@
+#include <iostream>
+#include <stdlib.h>
+
+using namespace std ;
+
+void printArray(int *array, int size){
+	for(int i = 0; i < size; i++){
+		cout << array[i] << " " ;
+	}
+
+}
+
+bool is3DSonar1D(int *array, int *hash, int iter_id, int p, int n){
+	int *hash = NULL ;
+	int p2 = p*p ;
+	int dif ;
+	for (int h1 = 0; h1 < p; h1++){
+		for(int h2 = 0; h2 < p; h2++){
+			if(h1 == 0 && h2 == 0)
+				continue ;
+			//printArray(hash, p2) ;cout << endl ;
+			for(int i = 0; i < p; i++){
+				if(p*i > n-1) 
+					break ;
+				for(int j = 0; j < p; j++){
+					if(i == 0 && j == 0)
+						continue ;
+					if((i+h1) % p == 0 && (j+h2) % p == 0)
+						continue ;
+					if(p*i+j > n-1)
+						break;
+					if( p * ((i + h1) % p) + ((j+h2) % p) > n - 1)
+						continue ;
+					dif = (array[ p *((i + h1) % p) + ((j+h2) % p)] - array[p*i+j]);
+					//cout <<i<< j<< h1 << h2 << "dif" <<dif<<endl ;
+					if(dif < 0)
+						dif = p2 + dif;
+					else
+						dif = dif % p2;
+					if (hash[dif] ==1){
+					//	printArray(hash, p2) ;cout << endl ;
+						return false ;
+					}
+					else	
+						hash[dif]=1 ;
+				}
+			}
+		}
+	}
+	return true ;
+}
+
+int main(int argc, char **argv){
+
+	int start, end, p, n ;
+	p = 3 ;
+	int counter = 0 ;
+	bool sonar = false ;
+	start = 3;
+	end = 3;
+	n = p*p ;
+	int *array = new int[n];
+	int *hash = (int *) calloc(p2, sizeof(int)) ;
+
+	for(int i = 0; i < n; i++)
+		array[i] = -1 ;
+	
+	array[1] = 0;
+	array[2] = atoi(argv[1]) ;	
+	while(end >= start){
+		counter++ ;	
+		sonar = false ;
+		if(array[end] + 1 > n-1){
+			array[end] = -1;
+			end-- ;
+			continue ;
+		}
+		array[end]++;
+		if(counter % 2000 == 0){ 
+			cout << "Check Point: " ; printArray(array, end+1);  cout << endl;
+			counter = 0;
+		}
+		if (is3DSonar1D(array, p, end+1)){
+			//cout <<"Costas";printArray(array, end+1) ; cout <<endl ;
+			sonar = true ;
+			if(end+1 == n){
+				cout <<"Sonar:";printArray(array, end+1);cout << endl;
+			}
+		}	
+		if(sonar && end < (n-1)){
+			end++ ;
+		}
+
+	}
+
+return 0 ;
+}

sonar3d.py

@@ -0,0 +1,48 @@
+import bisect
+from Sonar import *
+
+p = 3
+
+start = 2
+end = 2
+array = [-1] * (p*p) 
+array[1] = 0
+n = (p*p)
+
+c = Sonar()
+counter = 0
+
+while 1:
+        costas = 0
+
+        if end < start:
+                break
+        if array[end] + 1> n-1: #or len(next) == 0 or bisect.bisect(next, array[end]) >= len(next):
+                #bisect.insort(next, array[end])
+                array[end] = -1
+                end -=1
+                continue
+
+        #if not array[end] == 0:
+                #tmp = array[end]
+        #        array[end] += 1 #next[bisect.bisect_right(next, tmp)]
+                #next.remove(array[end])
+                #bisect.insort(next, tmp)
+        #else:
+
+        array[end] += 1
+	counter+= 1 
+	#print "Check Point:", array[:end+1]
+        if c.is3DSonar1D(array[:end+1], p, end+1):
+        	costas = 1
+		if end+1 == n: 
+        		print array[:end+1]
+
+
+        if costas and end < (n-1):
+                end += 1
+        elif costas and end == (n-1):
+                pass
+        else:
+                pass
+

sonar3dnxn.cpp

@@ -0,0 +1,111 @@
+#include <iostream>
+#include <stdlib.h>
+
+using namespace std ;
+
+void printArray(int *array, int size){
+	for(int i = 0; i < size; i++){
+		cout << array[i] << " " ;
+	}
+
+}
+
+void ZeroArray(int *array, int size){
+	for (int i = 0; i < size ; i++)
+		array[i] = 0 ;
+}
+
+bool is3DSonar1D(int *array, int *hash, int n1, int n2, int n){
+	int p2 = n1*n2 ;
+	int dif ;
+	int iter = 0;
+	ZeroArray(hash, p2) ;
+	for (int h1 = 0; h1 < n1; h1++){
+		for(int h2 = 0; h2 < n2; h2++){
+			if(h1 == 0 && h2 == 0)
+				continue ;
+			iter++ ;
+			//ZeroArray(hash,p2) ;
+		 	//cout <<"after 0 " ;printArray(hash, p2) ; cout <<endl;
+			for(int i = 0; i < n1; i++){
+				if(n2*i > n-1) 
+					break ;
+				for(int j = 0; j < n2; j++){
+					if(i == 0 && j == 0)
+						continue ;
+					if((i+h1) % n1 == 0 && (j+h2) % n2 == 0)
+						continue ;
+					if(n2*i+j > n-1)
+						break;
+					if( n2 * ((i + h1) % n1) + ((j+h2) % n2) > n - 1)
+						continue ;
+					dif = (array[ n2 *((i + h1) % n1) + ((j+h2) % n2)] - array[n2*i+j]);
+					//cout << h1 << " " << h2 << " n " << n <<endl ;
+					//cout <<i+h1<< j+h2 << i << j << array[ n2 *((i + h1) % n1) + ((j+h2) % n2)] << array[n2*i+j] << "dif" <<dif<<endl ;
+					//cout <<"Pos " << n2 *((i + h1) % n1) + ((j+h2) % n2) << n2*i+j << endl ;
+					if(dif < 0)
+						dif = p2 + dif;
+					else
+						dif = dif % p2;
+					if (hash[dif] == iter){
+						//cout << "Eq " <<hash[dif] << iter <<endl ;
+						//printArray(hash, p2) ;cout << endl ;
+						return false ;
+					}
+					else{	
+					//	cout << "FALSE" <<endl ;
+						hash[dif]=iter ;
+					}
+				}
+			}
+		}
+	}
+	return true ;
+}
+
+int main(int argc, char **argv){
+
+	int start, end, n1, n2, n ;
+	int counter = 0 ;
+	bool sonar = false ;
+	start = 3;
+	end = 3;
+	n1 = atoi(argv[1]) ;
+	n2 = atoi(argv[2]) ;
+	n = n1*n2 ;
+	int *array = new int[n];
+	int *hash = (int *) calloc(n, sizeof(int)) ;
+
+	for(int i = 0; i < n; i++)
+		array[i] = -1 ;
+	
+	array[1] = 0;
+	array[2] = atoi(argv[3]) ;	
+	while(end >= start){
+		counter++ ;	
+		sonar = false ;
+		if(array[end] + 1 > n-1){
+			array[end] = -1;
+			end-- ;
+			continue ;
+		}
+		array[end]++;
+		if(counter % 10000 == 0){ 
+			cout << "Check Point: " ; printArray(array, end+1);  cout << endl;
+			counter = 0;
+		}
+		if (is3DSonar1D(array, hash, n1, n2, end+1)){
+			//cout <<"Costas";printArray(array, end+1) ; cout <<endl ;
+			sonar = true ;
+			if(end+1 == n){
+				cout <<"Sonar:";printArray(array, end+1);cout << endl;
+			}
+		}	
+		if(sonar && end < (n-1)){
+			end++ ;
+		}
+
+	}
+
+return 0 ;
+}