Merge remote-tracking branch 'origin/parallel'

Conflicts:
	matlab2cpp/m2cpp.py
	matlab2cpp/rules/_expression.py
	matlab2cpp/rules/_reserved.py

Author: geirpa

m2cpp.py

@@ -32,7 +32,9 @@
 Automatically populate the `<filename>.py` file with datatype with suggestions
 if possible.""")
 parser.add_argument("-S", '--matlab-suggest', action="store_true",
-        help="""Creates a folder m2cpp_temp. In the folder the matlab file(s) to be translated are also put. These matlab file(s) are slightly modified so that they output data-type information of the variables to file(s). This output can then be used to set the datatypes for the translation.""")
+        help="""Creates a folder m2cpp_temp. In the folder the matlab file(s) to be translated are also put. \
+        These matlab file(s) are slightly modified so that they output data-type information of the variables \
+        to file(s). This output can then be used to set the datatypes for the translation.""")
 
 parser.add_argument("-r", '--reset', action="store_true",
         help="""\
@@ -58,16 +60,25 @@
 
 parser.add_argument("-p", "--paths_file", type=str, dest="paths_file",
         help="""\
-Flag and paths_file (-p path_to_pathsfile). m2cpp will look for matlab files in the location specified in the paths_file""")
+Flag and paths_file (-p path_to_pathsfile). m2cpp will look for matlab files in the location specified \
+in the paths_file""")
 
 parser.add_argument("-omp", '--enable-omp', action="store_true",
                     help="""\
-OpenMP code is inserted for Parfor and loops marked with the pragma %%#PARFOR (in Matlab code) when this flag is set.""")
+OpenMP code is inserted for Parfor and loops marked with the pragma %%#PARFOR (in Matlab code) when this \
+flag is set.""")
 
 parser.add_argument("-tbb", '--enable-tbb', action="store_true",
                     help="""\
 TBB code is inserted for Parfor and loops marked with the pragma %%#PARFOR (in Matlab code) when this flag is set.""")
 
+parser.add_argument("-ref", '--reference', action="store_true",
+                    help="""\
+For the generated C++ code, function input parameters are "copied by value" as default. With this flag some \
+input parameters in the generated code can be const references. There can be some performance advantage of using
+const references instead of "copied by value". Note that Matlab "copies by value". \
+The Matlab code you try to translate to C++ code could try read as well as write to this input variable. \
+The code generator doesn't perform an analysis to detect this and then "copy by value" for this variable.""")
 parser.add_argument("-l", '--line', type=int, dest="line",
         help="Only display code related to code line number `<line>`.")
 

matlab2cpp/__init__.py

@@ -78,7 +78,8 @@ def main(args):
     """
 
     builder = tree.builder.Builder(disp=args.disp, comments=args.comments,
-                                   original=args.original, enable_omp=args.enable_omp, enable_tbb=args.enable_tbb)
+                                   original=args.original, enable_omp=args.enable_omp, enable_tbb=args.enable_tbb,
+                                   reference=args.reference)
 
     paths_from_file = []
     #read setpath.m file and return string list of paths

matlab2cpp/configure/reserved.py

@@ -264,6 +264,14 @@ def Assigns_max(node):
         node[0].suggest = (0, var.mem)
         node[1].suggest = "int"
 
+def Get_fliplr(node):
+    if len(node) > 0:
+        node.type = node[0].type
+
+def Get_flipud(node):
+    if len(node) > 0:
+        node.type = node[0].type
+
 def Get_eye(node):
     #set eye type to cx_mat if LHS is complex type
     if node.group.cls == "Assign" and node.group[0].mem == 4:
@@ -288,6 +296,9 @@ def Get_triu(node):
 
 Var_eye = Get_eye
 
+def Get_trace(node):
+    node.type = node[0].type
+
 def Get_transpose(node):
     """Simple transpose
     """

matlab2cpp/m2cpp.py

@@ -111,19 +111,15 @@
         return X;
     }
 
-/*
-  template<typename eT>
-  inline typename arma::enable_if2<arma::is_real<eT>::value, arma::Col<eT> >::result fspan(eT a, eT step, eT b) {
-  arma::Col<eT> s;
-  int n = int((b - a) / step);
-  if (n < 0) return s;
-
-  s.set_size(n + 1);
-  for (int ii = 0; ii <= n; ii++)
-  s(ii) = step * ii + a;
-  return s;
-  }
-*/
+    inline arma::cx_mat ifft(arma::cx_mat X, int n, int dim)
+    {
+        if (dim == 1)
+            X = arma::ifft(X, n);
+        else
+            X = arma::strans(arma::ifft(arma::strans(X), n));
+        return X;
+    }
+    
 
     //template<typename eT>
     inline rowvec fspan(double a, double step, double b) {
@@ -194,6 +190,7 @@
         return A.n_elem;
     }
 
+    /*
     template<typename T>
     inline arma::Mat <typename T::elem_type> convmtx(const T& v, int m) {
 
@@ -208,6 +205,31 @@
             out = out.t();
         return out;
     }
+    */
+
+    template<typename T>
+    inline arma::Mat <typename T::elem_type> convmtx(const T& v, int m) {
+
+        arma::Mat<typename T::elem_type> out = zeros<arma::Mat<typename T::elem_type> >(v.n_elem + m - 1, m);
+        arma::Col<typename T::elem_type> aux((typename T::elem_type*)v.memptr(), v.n_elem);
+
+        if (v.n_rows == 1)
+        {
+            for (int ii = 0; ii < m; ii++) {
+                out.submat(ii, ii, ii + v.n_elem - 1, ii) = aux;
+            }
+        }
+        else
+        {
+            for (int ii = 0; ii < m; ii++) {
+                out.submat(ii, ii, ii + v.n_elem - 1, ii) = v;
+            }
+        }
+
+        if (v.n_rows == 1)
+            out = out.t();
+        return out;
+    }
 
     template <typename eT>
     inline typename arma::enable_if2< arma::is_real<typename eT::elem_type>::value, typename arma::Mat<typename eT::elem_type> >::result

matlab2cpp/rules/_expression.py

@@ -120,7 +120,7 @@ def Mul(node):
     #mem = max(node[0].mem, 2)
 
     if node.mem == 4 and node[0].dim == 0 and node[0].mem != 4:
-        out = "(cx_double) %(0)s"
+        out = "cx_double(%(0)s)"
     else:
         out = "%(0)s"
     index = 1
@@ -388,6 +388,9 @@ def Matrixdivision(node):
             elif child.mem < 2 and mem < 2:
                 out = out + "*1.0/" + str(child)
 
+            elif child.type == "int" and mem == 4:
+                out = out + "/" + "double(" + str(child) + ")"
+
             else:
                 out = out + "/" + str(child)
 
@@ -625,10 +628,10 @@ def Transpose(node):
     """
 
     # not complex type
-    if node.mem < 4:
-        return "arma::strans(", "", ")"
+    #if node.mem < 4:
+    #    return "arma::strans(", "", ")"
 
-    return "arma::trans(", "", ")"
+    return "arma::strans(", "", ")"
 
 def Ctranspose(node):
     """Complex transpose

matlab2cpp/rules/_func_return.py

@@ -80,9 +80,16 @@ def Params(node):
     """
 
     out = ""
-    for child in node:
-        out += ", " + type_string(child) + " " + str(child)
-    return out[2:]
+
+    # if -ref, -reference flag option
+    if node.project.builder.reference:
+        out += ", ".join(["const " + child.type + "& " + child.name if child.dim > 0 else
+                           child.type + " " + child.name for child in node])
+
+    else:
+        out = ", ".join([child.type + " " + child.name for child in node])
+
+    return out
 
 
 def Declares(node):

matlab2cpp/rules/_func_returns.py

@@ -154,9 +154,19 @@ def Params(node):
 
     # Create list of parameters
     out = ""
-    for child in node[:]:
-        out += ", " + type_string(child) + " " + str(child)
-    return out[2:]
+
+    # if -ref, -reference flag option
+    if node.project.builder.reference:
+
+        out += ", ".join(["const " + child.type + "& " + child.name if child.dim > 0 else
+                           child.type + " " + child.name for child in node])
+
+        return out
+
+    else:
+        out = ", ".join([child.type + " " + child.name for child in node])
+
+    return out
 
 
 def Declares(node):

matlab2cpp/rules/_program.py

@@ -91,17 +91,47 @@ def Headers(node):
 def Header(node):
     func = node.program[1][node.program[1].names.index(node.name)]
     if func.backend == "func_return":
-        code = func[1][0].type + " " + func.name + "(" +\
+
+        # if -ref, -reference flag option
+        if node.project.builder.reference:
+
+            code = func[1][0].type + " " + func.name + "(" +\
+                   ", ".join(["const " + p.type + "& " + p.name if p.dim > 0 else
+                           p.type + " " + p.name for p in func[2]]) + ") ;"
+
+        else:
+            code = func[1][0].type + " " + func.name + "(" +\
             ", ".join([p.type + " " + p.name for p in func[2]]) + ") ;"
 
+
     elif func.backend == "func_returns" and not func[1]:
-        code = "void " + func.name + "(" +\
+
+        # if -ref, -reference flag option
+        if node.project.builder.reference:
+            code = "void " + func.name + "(" +\
+                ", ".join(["const " + p.type + "& " + p.name if p.dim > 0 else
+                           p.type + " " + p.name for p in func[2]]) + ") ;"
+
+        else:
+            code = "void " + func.name + "(" +\
             ", ".join([p.type + " " + p.name for p in func[2]]) + ") ;"
 
     elif func.backend == "func_returns" and func[1]:
-        code = "void " + func.name + "(" +\
+
+        # if -ref, -reference flag option
+        if node.project.builder.reference:
+            code = "void " + func.name + "(" +\
+                ", ".join(["const " + p.type + "& " + p.name if p.dim > 0 else
+                           p.type + " " + p.name for p in func[2]]) + ", " +\
+                ", ".join([p.type + "& " + p.name for p in func[1]]) + ") ;"
+
+        else:
+            code = "void " + func.name + "(" +\
             ", ".join([p.type + " " + p.name for p in func[2]]) + ", " +\
             ", ".join([p.type + "& " + p.name for p in func[1]]) + ") ;"
+
+
+
     return code
 
 Include = "%(name)s"

matlab2cpp/rules/_reserved.py

@@ -14,8 +14,8 @@
 "eps", "exp", "log", "log2", "log10", "power", "floor", "ceil",
 "cos", "acos", "cosh", "acosh",
 "sin", "asin", "sinh", "asinh", "mod",
-"eye", "flipud", "length", "max", "min", "size", "chol",
-"transpose", "ctranspose",
+"eye", "fliplr", "flipud", "length", "max", "min", "size", "chol",
+"trace", "transpose", "ctranspose",
 "abs", "sqrt", "nextpow2", "fft", "ifft", "fft2", "ifft2", "hankel",
 "zeros", "ones", "round", "return", "rand",
 "qr",
@@ -533,6 +533,9 @@ def Get_eye(node):
 
     raise NotImplementedError
 
+def Get_trace(node):
+    return "arma::trace(", ", ", ")"
+
 def Get_transpose(node):
     """Simple transpose
     """
@@ -545,6 +548,9 @@ def Get_ctranspose(node):
 
     return "arma::trans(%(0)s)"
 
+def Get_fliplr(node):
+    return "arma::fliplr(%(0)s)"
+
 def Get_flipud(node):
     return "arma::flipud(%(0)s)"
 

matlab2cpp/rules/assign.py

@@ -50,7 +50,7 @@ def Assign(node):
         if lhs.dim == 0 and rhs.dim == 0:
 
             if lhs.mem >= rhs.mem:
-                out = "(" + lhs.type + ") " + out
+                out = "" + lhs.type + "(" + out + ")"
             else:
                 node.warning("Type reduction from %s to %s" %\
                         (rhs.type, lhs.type))
@@ -69,7 +69,7 @@ def Assign(node):
                 out = "conv_to<" + lhs.type + ">::from(%(1)s)"
             elif lhs.dim == 0 and rhs.dim == 0:
                 if lhs.mem == 4:
-                    out = "(" + lhs.type + ")" + " %(1)s"
+                    out = "" + lhs.type + "" + "(%(1)s)"
 
         # all the ways things are wrong
         elif lhs.dim > 0 and rhs.dim > 0: