Merge remote-tracking branch 'origin/master'

# Conflicts:
#	src/compas/hpc/geometry/basic_numba.py

Author: andrewtliew

.gitignore

@@ -109,6 +109,9 @@ ENV/
 libs/**
 !libs/PLACEHOLDER
 
+temp/**
+!temp/PLACEHOLDER
+
 src/.build/**
 *.rhl
 

src/compas/__init__.py

@@ -46,7 +46,7 @@
 DATA = os.path.abspath(os.path.join(HOME, 'samples'))
 DOCS = os.path.abspath(os.path.join(HOME, 'docs'))
 LIBS = os.path.abspath(os.path.join(HOME, 'libs'))
-TEMP = os.path.abspath(os.path.join(HOME, '__temp'))
+TEMP = os.path.abspath(os.path.join(HOME, 'temp'))
 
 
 def _find_resource(filename):

src/compas/geometry/algorithms/smoothing.py

@@ -2,6 +2,7 @@
 from __future__ import absolute_import
 from __future__ import division
 
+from copy import deepcopy
 
 from compas.geometry import centroid_points
 from compas.geometry import center_of_mass_polygon
@@ -118,7 +119,8 @@ def smooth_centroid(vertices,
     fixed = set(fixed)
 
     for k in range(kmax):
-        vertices_0 = {key: xyz for key, xyz in iter(vertices.items())}
+        vertices_0 = {key: xyz[:] for key, xyz in iter(vertices.items())}
+        # vertices_0 = deepcopy(vertices)
 
         for key, point in iter(vertices_0.items()):
             if key in fixed:
@@ -131,6 +133,10 @@ def smooth_centroid(vertices,
             vertices[key][1] += damping * (centroid[1] - point[1])
             vertices[key][2] += damping * (centroid[2] - point[2])
 
+            # vertices[key][0] = centroid[0]
+            # vertices[key][1] = centroid[1]
+            # vertices[key][2] = centroid[2]
+
         if callback:
             callback(vertices, k, callback_args)
 
@@ -236,7 +242,7 @@ def smooth_centerofmass(vertices,
             raise Exception('The callback is not callable.')
 
     for k in range(kmax):
-        vertices_0 = {key: xyz for key, xyz in iter(vertices.items())}
+        vertices_0 = {key: xyz[:] for key, xyz in iter(vertices.items())}
 
         for key, point in iter(vertices_0.items()):
             if key in fixed:
@@ -341,7 +347,7 @@ def smooth_resultant(vertices,
     fixed = set(fixed)
 
     for k in range(kmax):
-        vertices_0 = {key: xyz for key, xyz in iter(vertices.items())}
+        vertices_0 = {key: xyz[:] for key, xyz in iter(vertices.items())}
 
         for key, point in iter(vertices_0.items()):
             if key in fixed:
@@ -453,7 +459,7 @@ def smooth_area(vertices,
     fixed = set(fixed)
 
     for k in range(kmax):
-        vertices_0 = {key: point for key, point in iter(vertices.items())}
+        vertices_0 = {key: point[:] for key, point in iter(vertices.items())}
 
         face_centroid = {fkey: centroid_points([vertices[key] for key in keys]) for fkey, keys in iter(faces.items())}
         face_area = {fkey: area_polygon([vertices[key] for key in keys]) for fkey, keys in iter(faces.items())}
@@ -742,17 +748,24 @@ def network_smooth_resultant(network, fixed=None, kmax=100, damping=0.05, callba
 
 if __name__ == "__main__":
 
+    import os
+    import sys
+
     import compas
 
     from compas.datastructures import Mesh
     from compas.plotters import MeshPlotter
 
     mesh = Mesh.from_obj(compas.get('faces.obj'))
 
+    edges = list(mesh.edges())
+
     fixed = [key for key in mesh.vertices() if mesh.vertex_degree(key) == 2]
 
     plotter = MeshPlotter(mesh, figsize=(10, 7))
 
+    images = []
+
     lines = []
     for u, v in mesh.edges():
         lines.append({
@@ -763,20 +776,32 @@ def network_smooth_resultant(network, fixed=None, kmax=100, damping=0.05, callba
         })
     plotter.draw_lines(lines)
 
-    plotter.draw_vertices(facecolor={key: '#ff0000' for key in fixed})
+    plotter.draw_vertices(facecolor={key: '#ff0000' for key in fixed}, text={key: key for key in fixed})
     plotter.draw_faces()
     plotter.draw_edges()
 
     plotter.update(pause=1.0)
 
+    # filepath = os.path.join(compas.TEMP, 'image_{}.jpg'.format(0))
+    # plotter.save(filepath)
+    # images.append(filepath)
+
     def callback(mesh, k, args):
         print(k)
         plotter.update_vertices()
         plotter.update_faces()
         plotter.update_edges()
         plotter.update(pause=0.001)
 
+        # filepath = os.path.join(compas.TEMP, 'image_{}.jpg'.format(k + 1))
+        # plotter.save(filepath)
+        # images.append(filepath)
+
     mesh_smooth_centroid(mesh, kmax=50, fixed=fixed, callback=callback)
 
-    plotter.update(pause=1.0)
+    # plotter.saveas_gif(os.path.join(compas.TEMP, 'smoothing.gif'), images)
+
+    for filepath in images:
+        os.remove(filepath)
+
     plotter.show()

src/compas/hpc/__init__.py

@@ -70,45 +70,61 @@
     circle_from_points_xy_numba
 
 
-solvers
+core
 ====
 
+cuda
+----
+
 .. autosummary::
     :toctree: generated/
 
-    devo_numba
 
+euler
+-----
 
-core
-=====
+.. autosummary::
+    :toctree: generated/
+
+    euler.connect_to_euler
+    euler.load_euler_module
+    euler.recieve_file_from_euler
+    euler.send_file_to_euler
+    euler.send_folder_to_euler
+    euler.show_euler_jobs
+    euler.show_euler_quotas
+    euler.show_euler_modules
+    euler.show_euler_module_info
+    euler.show_euler_resources
+    euler.submit_job
+    euler.kill_job
+    euler.sync_folder_to_euler
+
+numba
+-----
 
 .. autosummary::
     :toctree: generated/
 
-    connect_to_euler
-    load_euler_module
-    recieve_file_from_euler
-    send_file_to_euler
-    send_folder_to_euler
-    show_euler_jobs
-    show_euler_quotas
-    show_euler_modules
-    show_euler_module_info
-    show_euler_resources
-    submit_job
-    kill_job
-    sync_folder_to_euler
+    numba.numba_cross
+    numba.numba_vdot
+    numba.numba_dot
+    numba.numba_length
+    numba.numba_subtract
 
-"""
 
+opencl
+------
+
+.. autosummary::
+    :toctree: generated/
+
+
+"""
 from .geometry import *
-from .core import *
 from .algorithms import *
-from .solvers import *
 
 from .geometry import __all__ as a
-from .core import __all__ as b
-from .algorithms import __all__ as c
-from .solvers import __all__ as d
+from .algorithms import __all__ as b
 
-__all__ = a + b + c + d
+__all__ = a + b

src/compas/hpc/algorithms/devo_numba.py

@@ -0,0 +1,129 @@
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+
+from numba import jit
+
+from numpy import array
+from numpy import argmin
+from numpy import min
+from numpy import random
+from numpy import zeros
+
+
+__author__     = ['Andrew Liew <[email protected]>']
+__copyright__  = 'Copyright 2017, BLOCK Research Group - ETH Zurich'
+__license__    = 'MIT License'
+__email__      = '[email protected]'
+
+
+__all__ = [
+    'devo_numba'
+]
+
+
+args = 0
+
+
+@jit(nogil=True, nopython=True)
+def devo_numba(bounds, population, iterations):
+    """ Call the Numba accelerated differential evolution solver.
+
+    Parameters:
+        bounds (array): Lower and upper bounds for each DoF.
+        population (int): Number of agents in the population.
+        iterations (int): Number of cross-over cycles or steps to perform.
+
+    Returns:
+        array: Values that give the optimum (minimised) function.
+    """
+
+    F = 0.8
+    CR = 0.9
+
+    # Heading
+
+    print('\n---------------------------------')
+    print('Differential Evolution started...')
+    print('---------------------------------')
+
+    # Setup population
+
+    k = bounds.shape[0]
+    agents = random.rand(k, population)
+    for i in range(k):
+        for j in range(population):
+            agents[i, j] *= bounds[i, 1] - bounds[i, 0]
+            agents[i, j] += bounds[i, 0]
+    candidates = zeros((population, population - 1))
+    for i in range(population):
+        c = 0
+        for j in range(population - 1):
+            if j == i:
+                c += 1
+            candidates[i, j] = c
+            c += 1
+    ts = 0
+    fun = zeros(population)
+    for i in range(population):
+        fun[i] = _fn(agents[:, i], args)
+    fopt = min(fun)
+
+    # print(' ')
+    # print('Generation: ', ts, '  fopt: ', fopt)
+
+    # Start evolution
+
+    agents_ = zeros((k, population))
+    while ts < iterations:
+        ind = random.rand(k, population) < CR
+        for i in range(population):
+            rands = candidates[i, :]
+            random.shuffle(rands)
+            ind0 = int(candidates[i, int(rands[0])])
+            ind1 = int(candidates[i, int(rands[1])])
+            ind2 = int(candidates[i, int(rands[2])])
+            ac = agents[:, ind0]
+            bc = agents[:, ind1]
+            cc = agents[:, ind2]
+            for j in range(k):
+                if ind[j, i]:
+                    agents_[j, i] = ac[j] + F * (bc[j] - cc[j])
+            fun_ = _fn(agents_[:, i], args)
+            if fun_ < fun[i]:
+                agents[:, i] = agents_[:, i]
+                fun[i] = fun_
+        fopt = min(fun)
+        xopt = agents[:, argmin(fun)]
+        ts += 1
+
+        # print('Generation: ', ts, '  fopt: ', fopt)
+
+    # Summary
+
+    # print('\n-------------------------------')
+    # print('Differential Evolution finished')
+    # print('fopt: ', fopt)
+    # print('-------------------------------')
+
+    return xopt
+
+
+@jit(nogil=True, nopython=True)
+def _fn(u, args):
+    # Booth's function, fopt=0, uopt=(1, 3)
+    x = u[0]
+    y = u[1]
+    z = (x + 2 * y - 7)**2 + (2 * x + y - 5)**2
+    return z
+
+
+# ==============================================================================
+# Testing
+# ==============================================================================
+
+if __name__ == "__main__":
+
+    bounds = array([[-10., 10.], [-10., 10.]])
+    xopt = devo_numba(bounds, population=20, iterations=100)
+    print(xopt)

src/compas/hpc/core/__init__.py

@@ -1,5 +1,5 @@
-from .euler_ import *
+from .euler import *
 
-from .euler_ import __all__ as a
+from .euler import __all__ as a
 
 __all__ = a

src/compas/hpc/core/cuda_/__init__.py renamed to src/compas/hpc/core/cuda/__init__.py

@@ -1,3 +1,7 @@
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+
 from numpy import array
 from numpy import float32
 from numpy import float64

src/compas/hpc/core/cuda_/_array.py renamed to src/compas/hpc/core/cuda/array.py

@@ -1,8 +1,12 @@
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+
 from numpy import float64
 from numpy import ceil
 
-from compas.hpc.cuda._math import cuda_sqrt
-from compas.hpc.cuda._math import cuda_sum
+from compas.hpc.cuda.math import cuda_sqrt
+from compas.hpc.cuda.math import cuda_sum
 
 try:
     import pycuda

src/compas/hpc/core/cuda_/_linalg.py renamed to src/compas/hpc/core/cuda/linalg.py

@@ -1,3 +1,7 @@
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+
 try:
     import pycuda
     import pycuda.autoinit