3nar fonctionnel

3nar.py

@@ -21,6 +21,17 @@ class Nnnar:
             raise AttributeError("Error: wrong number of dimensions")
         self.space[*self.getSpaceIdxFromCoord(coord)].append(Point(coord, value))
 
+    def getValueOfPoint(self, coord,nbNearest):
+        points = self.getNNearest(coord, nbNearest)
+        value = points[0].value
+        for idx in range(1,len(points)):
+            tvalue = points[idx].value
+            for i in range(len(tvalue)):
+                value[i] += tvalue[i]
+        for i in range(len(value)):
+            value[i] = value[i] / nbNearest
+        return value
+
     def getNNearest(self, coord, nbNearest):
         idx = self.getSpaceIdxFromCoord(coord)
         nbAround = 0
@@ -29,15 +40,14 @@ class Nnnar:
             selected = []
             subSpaceIdxList = getSpaceIdxAround(idx, nbAround, self)
             for subSpaceIdx in subSpaceIdxList:
-                print(subSpaceIdx)
-                print(self.space[subSpaceIdx])
-                selected += selectPointsInRange(self.space[subSpaceIdx],coord,nbAround*self.unit)
+                selected += selectPointsInRange(self.space[tuple(subSpaceIdx)],coord,nbAround*self.unit,self.space)
             nbAround += 1
         found = []
         dist = []
         i=0
         while len(found) < nbNearest:
-            found += selected[i]
+            found.append(selected[i])
+            dist.append(selected[i].getDistFromCoord(coord))
             i+=1
         maxDistIdx = foundMaxIndex(dist)
         maxDist = max(dist)
@@ -73,9 +83,9 @@ class Point:
 
 
 
+n = Nnnar(3, 0, 3, 2)
 
-n = Nnnar(2, 0, 3, 2)
-
-n.addPoint(np.array([1, 0.8]), 1)
+n.addPoint(np.array([1, 0.8,1.5]), [0.2,0.5])
+n.addPoint(np.array([0.2, 1.8,1.2]), [0.4,0.7])
 
-print(n.getNNearest(np.array([1,0.8]),1))
+print(n.getValueOfPoint(np.array([1, 1, 1]), 2))

function.py

@@ -8,8 +8,11 @@ def getSpaceIdxAround(center, nbAround, space):
         space.calculatedSpaceAroundIdx.append(spaceAround)
     return applySapceAroundToCase(center,spaceAround,space)
 
-def selectPointsInRange(points, coord, distance):
+def selectPointsInRange(points, coord, distance,space):
     found = []
+    for point in points:
+        if point.getDistFromCoord(coord) <= distance:
+            found.append(point)
     return found
 
 def foundMaxIndex(dist):

spaceAround.py

@@ -1,68 +1,70 @@
+import numpy as np
 from sympy.utilities.iterables import multiset_permutations
 
 def findCoordAround(center, nbAround):
+    nbDimention = len(center)
     find = []
-    for i in range(len(center)):
-        find = getNCoordDiff(center,find,i,nbAround)
+    for i in range(1, nbDimention + 1):
+        find = getNCoordDifferente(center, find, i, nbAround)
+    # print(len(find),(nbAround*2+1)*(nbAround*2+1))
+    # input()
     return find
 
-def getNCoordDiff(center,find,nbDiffValue, nbAround):
+def getNCoordDifferente(center, find, nbDifferanteValue, nbAround):
     coord = []
-    if (-nbAround+nbAround >= nbDiffValue):
-        return find
-    for i in range(nbDiffValue):
-        coord.append(-nbAround+i)
+    for i in range(nbDifferanteValue):
+        if -nbAround + i > nbAround:
+            return find
+        coord.append(-nbAround + i)
+    find = getCompletVariationOfCoord(center, find, coord)
+    
     while True:
         modified = False
-        cursor = len(coord)-1
-        while(not modified):
-            if (cursor<0):
+        cursor = len(coord) - 1
+        while not modified:
+            if cursor < 0 or cursor == len(coord):
                 return find
-            if (coord[cursor]+len(coord)-1-cursor<nbAround):
+            if coord[cursor] + len(coord) - 1 - cursor < nbAround:
                 modified = True
                 coord[cursor] += 1
-                val = coord[cursor] +1
+                val = coord[cursor] + 1
                 cursor += 1
-                while(cursor<len(coord)):
+                while cursor < len(coord):
                     coord[cursor] = val
-                    cursor +=1
+                    cursor += 1
                     val += 1
             else:
                 cursor -= 1
-        find = getCompletVariationOfCoord(center,find,coord)
-    return find
+        find = getCompletVariationOfCoord(center, find, coord)
 
-def getCompletVariationOfCoord(center,find,partialCoord):
-    coord = []
-    for i in range(len(partialCoord)):
-        coord.append(partialCoord[i])
+def getCompletVariationOfCoord(center, find, partialCoord):
+    coord = partialCoord[:]
     while len(coord) != len(center):
         coord.append(partialCoord[0])
-    find = getPermutationOfCoord(center,find,coord)
+    find = getPermutationOfCoord(center, find, coord)
+    
     while True:
-        cursor = len(coord)-1
         modified = False
+        cursor = len(coord) - 1
         while not modified:
-            if (cursor == len(partialCoord)-1):
+            if cursor == len(partialCoord) - 1:
                 return find
-            if (coord[cursor]!=partialCoord[len(partialCoord)-1]):
+            if coord[cursor] != partialCoord[len(partialCoord) - 1]:
                 modified = True
                 afterCursor = 0
-                while afterCursor<len(partialCoord) and coord[cursor] != partialCoord[afterCursor]:
-                    afterCursor +=1
+                while afterCursor < len(partialCoord) and coord[cursor] != partialCoord[afterCursor]:
+                    afterCursor += 1
                 afterCursor += 1
-                while(cursor<len(coord)):
+                while cursor < len(coord):
                     coord[cursor] = partialCoord[afterCursor]
                     cursor += 1
             else:
                 cursor -= 1
-        find = getPermutationOfCoord(center,find,coord)
-    return find
+        find = getPermutationOfCoord(center, find, coord)
 
-def getPermutationOfCoord(center,find,coord):
-    find.append(coord)
+def getPermutationOfCoord(center, find, coord):
     for perm in multiset_permutations(coord):
-        find.append(perm)
+        find.append(list(perm))
     return find
 
 def applySapceAroundToCase(center,spaceAround,space):
@@ -72,9 +74,9 @@ def applySapceAroundToCase(center,spaceAround,space):
         for i in range(len(spaceAround[y])):
             if not estBon:
                 continue
-            spaceAround[y][i] += center[i]
-            estBon = estBon and space.minCoord < spaceAround[y][i] < space.maxCoord
+            else :
+                spaceAround[y][i] += center[i]
+                estBon = estBon and 0 <= spaceAround[y][i] <= space.nbSubdivisions-1
         if estBon:
             reelSpaceAround.append(spaceAround[y])
-    print(reelSpaceAround)
     return reelSpaceAround