gradgen 0.1.0__tar.gz

gradgen-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Pantelis Sopasakis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gradgen-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include gradgen/templates/*
+include gradgen/templates/**/*
+include VERSION
+

gradgen-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: gradgen
+Version: 0.1.0
+Summary: Gradient computation with AD for optimal control
+Home-page: https://github.com/alphaville/gradgen
+Author: ['Jie Lin', 'Pantelis Sopasakis']
+Author-email: p.sopasakis@gmail.com
+License: MIT License
+Keywords: optimization,nonconvex,embedded
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Rust
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Embedded Systems
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+
+# GradGen
+
+Code generation for cost gradient
+
+### Installation instructions
+
+To build this project locally:
+
+- Create a virtual environment: `virtualenv -p python3 venv`
+- Activate the virtual environment. On Linux/MacOS, run `source venv/bin/activate`
+- Install the project: `pip install .`
+
+The folder `playground` can be used during the design phase of the project to try out different things, but it should be removed for release.
+
+

gradgen-0.1.0/README.md

@@ -0,0 +1,15 @@
+# GradGen
+
+Code generation for cost gradient
+
+### Installation instructions
+
+To build this project locally:
+
+- Create a virtual environment: `virtualenv -p python3 venv`
+- Activate the virtual environment. On Linux/MacOS, run `source venv/bin/activate`
+- Install the project: `pip install .`
+
+The folder `playground` can be used during the design phase of the project to try out different things, but it should be removed for release.
+
+

gradgen-0.1.0/VERSION

@@ -0,0 +1 @@
+0.1.0

gradgen-0.1.0/gradgen/__init__.py

@@ -0,0 +1,2 @@
+from gradgen.cost_gradient import *
+from gradgen.definitions import *

gradgen-0.1.0/gradgen/cost_gradient.py

@@ -0,0 +1,227 @@
+import casadi.casadi as cs
+import subprocess as subp
+import os
+import shutil
+import jinja2
+from gradgen.definitions import *
+
+
+class CostGradient:
+
+    def __init__(self, x, u, f, ell, vf, N):
+        """
+        Create new CostGradient object
+
+        :param x: state symbol
+        :param u: input symbol
+        :param f: system dynamics symbol (depends on x, u)
+        :param ell: cost function symbol (depends on x, u)
+        :param vf: terminal cost symbol (depends on x)
+        :param N: prediction horizon (int) 
+        """
+        self.__x = x
+        self.__u = u
+        self.__f = f
+        self.__ell = ell
+        self.__vf = vf
+        self.__N = N
+        self.__nx = x.size()[0]
+        self.__nu = u.size()[0]
+        self.__d = cs.SX.sym('d', self.__nx)
+        self.__jfx = None
+        self.__jfu = None
+        self.__ellx = None
+        self.__ellu = None
+        self.__vfx = None
+        self.__f_fun = None
+        self.__jfx_fun = None
+        self.__jfu_fun = None
+        self.__ell_fun = None
+        self.__ellx_fun = None
+        self.__ellu_fun = None
+        self.__vf_fun = None
+        self.__vfx_fun = None
+        self.__name = 'gradgenz'
+        self.__destination_path = 'codegenz'
+
+    def __target_root_dir(self):
+        trgt_root_abspath = os.path.join(self.__destination_path, self.__name)
+        return os.path.abspath(trgt_root_abspath)
+
+    def __target_externc_dir(self):
+        dest_abspath = os.path.join(
+            self.__destination_path, self.__name, 'casadi_'+self.__name, 'extern')
+        return os.path.abspath(dest_abspath)
+
+    def __target_casadirs_dir(self):
+        casadirs_abspath = os.path.join(
+            self.__destination_path, self.__name, 'casadi_'+self.__name)
+        return os.path.abspath(casadirs_abspath)
+
+    def __create_dirs(self):
+        if not os.path.exists(self.__target_externc_dir()):
+            os.makedirs(self.__target_externc_dir())
+        casadi_src_path = os.path.join(
+            self.__destination_path, self.__name, 'casadi_'+self.__name, 'src')
+        main_src_path = os.path.join(
+            self.__destination_path, self.__name, 'src')
+        if not os.path.exists(casadi_src_path):
+            os.makedirs(casadi_src_path)
+        if not os.path.exists(main_src_path):
+            os.makedirs(main_src_path)
+
+    @staticmethod
+    def __get_template(name, subdir=None):
+        subdir_path = templates_subdir(subdir)
+        file_loader = jinja2.FileSystemLoader(subdir_path)
+        env = jinja2.Environment(loader=file_loader, autoescape=True)
+        return env.get_template(name)
+
+    def with_name(self, name):
+        self.__name = name
+        return self
+
+    def with_target_path(self, dst_path):
+        self.__destination_path = dst_path
+        return self
+
+    def __create_gradients(self):
+        self.__jfx = cs.jacobian(self.__f, self.__x).T @ self.__d
+        self.__jfu = cs.jacobian(self.__f, self.__u).T @ self.__d
+        self.__ellx = cs.jacobian(self.__ell, self.__x).T
+        self.__ellu = cs.jacobian(self.__ell, self.__u).T
+        self.__vfx = cs.jacobian(self.__vf, self.__x).T
+
+    def __function_name(self, fname):
+        return 'casadi_' + self.__name + '_' + fname
+
+    def __generate_casadi_functions(self):
+        self.__f_fun = cs.Function(self.__function_name('f'), [self.__x, self.__u], [
+            self.__f], ['x', 'u'], ['f'])
+        self.__jfx_fun = cs.Function(self.__function_name(
+            'jfx'), [self.__x, self.__u, self.__d], [self.__jfx], ['x', 'u', 'd'], ['jfx'])
+        self.__jfu_fun = cs.Function(self.__function_name(
+            'jfu'), [self.__x, self.__u, self.__d], [self.__jfu], ['x', 'u', 'd'], ['jfu'])
+        self.__ell_fun = cs.Function(self.__function_name(
+            'ell'), [self.__x, self.__u], [self.__ell], ['x', 'u'], ['ell'])
+        self.__ellx_fun = cs.Function(self.__function_name('ellx'), [self.__x, self.__u], [
+            self.__ellx], ['x', 'u'], ['ellx'])
+        self.__ellu_fun = cs.Function(self.__function_name('ellu'), [self.__x, self.__u], [
+            self.__ellu], ['x', 'u'], ['ellu'])
+        self.__vf_fun = cs.Function(self.__function_name(
+            'vf'), [self.__x], [self.__vf], ['x'], ['vf'])
+        self.__vfx_fun = cs.Function(self.__function_name(
+            'vfx'), [self.__x], [self.__vfx], ['x'], ['vfx'])
+
+    def __generate_c_code(self):
+        c_code_filename = 'casadi_functions.c'
+        codegen = cs.CodeGenerator(c_code_filename)
+        codegen.add(self.__f_fun)
+        codegen.add(self.__jfx_fun)
+        codegen.add(self.__jfu_fun)
+        codegen.add(self.__ell_fun)
+        codegen.add(self.__ellx_fun)
+        codegen.add(self.__ellu_fun)
+        codegen.add(self.__vf_fun)
+        codegen.add(self.__vfx_fun)
+        codegen.generate()
+        # Move generated C code to destination directory
+        target_dir = self.__target_externc_dir()
+        shutil.move(c_code_filename, os.path.join(target_dir, c_code_filename))
+
+    def __generate_glob_header(self):
+        global_header_template = CostGradient.__get_template(
+            'global_header.h.tmpl', subdir='c')
+        global_header_rendered = global_header_template.render(
+            name=self.__name,
+            f=self.__f_fun,
+            jfx=self.__jfx_fun,
+            jfu=self.__jfu_fun,
+            ell=self.__ell_fun,
+            ellx=self.__ellx_fun,
+            ellu=self.__ellu_fun,
+            vf=self.__vf_fun,
+            vfx=self.__vfx_fun,
+            N=self.__N,
+            nx=self.__nx,
+            nu=self.__nu
+        )
+        glob_header_target_path = os.path.join(
+            self.__target_externc_dir(), "glob_header.h")
+        with open(glob_header_target_path, "w") as fh:
+            fh.write(global_header_rendered)
+
+    def __generate_c_interface(self):
+        c_interface_template = CostGradient.__get_template(
+            'autograd_interface.c.tmpl', subdir='c')
+        c_interface_rendered = c_interface_template.render(name=self.__name)
+        c_interface_target_path = os.path.join(
+            self.__target_externc_dir(), "interface.c")
+        with open(c_interface_target_path, "w") as fh:
+            fh.write(c_interface_rendered)
+
+    def __prepare_casadi_rs(self):
+        # Cargo.toml [casadi]
+        cargo_template = CostGradient.__get_template(
+            'Cargo.toml', subdir='casadi-rs')
+        cargo_rendered = cargo_template.render(name=self.__name)
+        cargo_target_path = os.path.join(
+            self.__target_casadirs_dir(), "Cargo.toml")
+        with open(cargo_target_path, "w") as fh:
+            fh.write(cargo_rendered)
+        # build.rs
+        build_rs_template = CostGradient.__get_template(
+            'build.rs', subdir='casadi-rs')
+        build_rs_rendered = build_rs_template.render(name=self.__name)
+        build_rs_target_path = os.path.join(
+            self.__target_casadirs_dir(), "build.rs")
+        with open(build_rs_target_path, "w") as fh:
+            fh.write(build_rs_rendered)
+        # lib.rs
+        casadi_lib_rs_template = CostGradient.__get_template(
+            'lib.rs', subdir='casadi-rs')
+        casadi_lib_rs_rendered = casadi_lib_rs_template.render(
+            name=self.__name,
+            nx=self.__nx,
+            nu=self.__nu,
+            N=self.__N)
+        casadi_lib_rs_target_path = os.path.join(
+            self.__target_casadirs_dir(), "src", "lib.rs")
+        with open(casadi_lib_rs_target_path, "w") as fh:
+            fh.write(casadi_lib_rs_rendered)
+
+    def __generate_rust_lib(self):
+        # Cargo
+        cargo_template = CostGradient.__get_template(
+            'Cargo.toml', subdir='rust')
+        cargo_rendered = cargo_template.render(name=self.__name)
+        cargo_target_path = os.path.join(
+            self.__target_root_dir(), "Cargo.toml")
+        with open(cargo_target_path, "w") as fh:
+            fh.write(cargo_rendered)
+        # lib
+        lib_template = CostGradient.__get_template('lib.rs', subdir='rust')
+        lib_rendered = lib_template.render(name=self.__name)
+        lib_target_path = os.path.join(
+            self.__target_root_dir(), "src", "lib.rs")
+        with open(lib_target_path, "w") as fh:
+            fh.write(lib_rendered)
+
+    def __cargo_build(self):
+        cmd = ['cargo', 'build', '-q']
+        p = subp.Popen(cmd, cwd=self.__target_root_dir())
+        process_completion = p.wait()
+        if process_completion != 0:
+            raise Exception('Rust build failed')
+
+    def build(self, no_rust_build=False):
+        self.__create_dirs()
+        self.__create_gradients()
+        self.__generate_casadi_functions()
+        self.__generate_c_code()
+        self.__generate_glob_header()
+        self.__generate_c_interface()
+        self.__prepare_casadi_rs()
+        self.__generate_rust_lib()
+        if not no_rust_build:
+            self.__cargo_build()

gradgen-0.1.0/gradgen/definitions.py

@@ -0,0 +1,16 @@
+import pkg_resources
+
+
+def templates_dir():
+    """Directory where the templates are found (for internal use, mainly)"""
+    return pkg_resources.resource_filename('gradgen', 'templates/')
+
+
+def templates_subdir(subdir=None):
+    """
+    Directory where the templates are found and subfolder relative
+    to that path(for internal use, mainly)
+    """
+    if subdir is None:
+        return templates_dir()
+    return pkg_resources.resource_filename('gradgen', 'templates/%s/' % subdir)

gradgen-0.1.0/gradgen/templates/c/autograd_interface.c.tmpl

@@ -0,0 +1,390 @@
+/*
+clang -fPIC -shared casadi_functions.c -o casadi_functions.so
+clang -DTEST_INTERFACE -o test interface.c casadi_functions.so -lm
+*/
+
+#include <stdlib.h>
+
+/*
+ * This is to be used ONLY for DEBUG purposes
+ * Compile with -DTEST_INTERFACE
+ */
+#ifdef TEST_INTERFACE
+#include <stdio.h>
+#endif
+
+#include "glob_header.h"
+
+#ifndef casadi_real
+#define casadi_real double
+#endif
+
+#ifndef casadi_int
+#define casadi_int long long int
+#endif
+
+extern int casadi_{{name}}_f(
+    const casadi_real **arg,
+    casadi_real **res,
+    casadi_int *iw,
+    casadi_real *w,
+    int mem);
+
+extern int casadi_{{name}}_jfx(
+    const casadi_real **arg,
+    casadi_real **res,
+    casadi_int *iw,
+    casadi_real *w,
+    int mem);
+
+extern int casadi_{{name}}_jfu(
+    const casadi_real **arg,
+    casadi_real **res,
+    casadi_int *iw,
+    casadi_real *w,
+    int mem);
+
+extern int casadi_{{name}}_ell(
+    const casadi_real **arg,
+    casadi_real **res,
+    casadi_int *iw,
+    casadi_real *w,
+    int mem);
+
+extern int casadi_{{name}}_ellx(
+    const casadi_real **arg,
+    casadi_real **res,
+    casadi_int *iw,
+    casadi_real *w,
+    int mem);
+
+extern int casadi_{{name}}_ellu(
+    const casadi_real **arg,
+    casadi_real **res,
+    casadi_int *iw,
+    casadi_real *w,
+    int mem);
+
+extern int casadi_{{name}}_vf(
+    const casadi_real **arg,
+    casadi_real **res,
+    casadi_int *iw,
+    casadi_real *w,
+    int mem);
+
+extern int casadi_{{name}}_vfx(
+    const casadi_real **arg,
+    casadi_real **res,
+    casadi_int *iw,
+    casadi_real *w,
+    int mem);
+
+
+/* -------------------------- */
+/*     Integer Workspaces     */
+/* -------------------------- */
+
+#if F_SZ_IW_{{ name | upper}} > 0
+static casadi_int iws_f[F_SZ_IW_{{ name | upper}}];  
+#else
+static casadi_int *iws_f = NULL;
+#endif
+
+#if JFX_SZ_IW_{{ name | upper}} > 0
+static casadi_int iws_jfx[JFX_SZ_IW_{{ name | upper}}];  
+#else
+static casadi_int *iws_jfx = NULL;
+#endif
+
+
+#if JFU_SZ_IW_{{ name | upper}} > 0
+static casadi_int iws_jfu[JFU_SZ_IW_{{ name | upper}}];  
+#else
+static casadi_int *iws_jfu = NULL;
+#endif
+
+#if ELL_SZ_IW_{{ name | upper}} > 0
+static casadi_int iws_ell[ELL_SZ_IW_{{ name | upper}}];  
+#else
+static casadi_int *iws_ell = NULL;
+#endif
+
+#if ELLX_SZ_IW_{{ name | upper}} > 0
+static casadi_int iws_ellx[ELLX_SZ_IW_{{ name | upper}}];  
+#else
+static casadi_int *iws_ellx = NULL;
+#endif
+
+#if ELLU_SZ_IW_{{ name | upper}} > 0
+static casadi_int iws_ellu[ELLU_SZ_IW_{{ name | upper}}];  
+#else
+static casadi_int *iws_ellu = NULL;
+#endif
+
+#if VF_SZ_IW_{{ name | upper}} > 0
+static casadi_int iws_vf[VF_SZ_IW_{{ name | upper}}];  
+#else
+static casadi_int *iws_vf = NULL;
+#endif
+
+#if VFX_SZ_IW_{{ name | upper}} > 0
+static casadi_int iws_vfx[VFX_SZ_IW_{{ name | upper}}];  
+#else
+static casadi_int *iws_vfx = NULL;
+#endif
+
+
+/* -------------------------- */
+/*       Real Workspaces      */
+/* -------------------------- */
+
+#if F_SZ_W_{{ name | upper}} > 0
+static casadi_real ws_f[F_SZ_W_{{ name | upper}}];
+#else
+static casadi_real *ws_f = NULL;
+#endif
+
+#if JFX_SZ_W_{{ name | upper}} > 0
+static casadi_real ws_jfx[JFX_SZ_W_{{ name | upper}}];
+#else
+static casadi_real *ws_jfx = NULL;
+#endif
+
+#if JFU_SZ_W_{{ name | upper}} > 0
+static casadi_real ws_jfu[JFU_SZ_W_{{ name | upper}}];
+#else
+static casadi_real *ws_jfu = NULL;
+#endif
+
+#if ELL_SZ_W_{{ name | upper}} > 0
+static casadi_real ws_ell[ELL_SZ_W_{{ name | upper}}];
+#else
+static casadi_real *ws_ell = NULL;
+#endif
+
+#if ELLX_SZ_W_{{ name | upper}} > 0
+static casadi_real ws_ellx[ELLX_SZ_W_{{ name | upper}}];
+#else
+static casadi_real *ws_ellx = NULL;
+#endif
+
+#if ELLU_SZ_W_{{ name | upper}} > 0
+static casadi_real ws_ellu[ELLU_SZ_W_{{ name | upper}}];
+#else
+static casadi_real *ws_ellu = NULL;
+#endif
+
+#if VF_SZ_W_{{ name | upper}} > 0
+static casadi_real ws_vf[VF_SZ_W_{{ name | upper}}];
+#else
+static casadi_real *ws_vf = NULL;
+#endif
+
+#if VFX_SZ_W_{{ name | upper}} > 0
+static casadi_real ws_vfx[VFX_SZ_W_{{ name | upper}}];
+#else
+static casadi_real *ws_vfx = NULL;
+#endif
+
+
+/* -------------------------- */
+/*        Result Spaces       */
+/* -------------------------- */
+static casadi_real *f_res[F_SZ_RES_{{ name | upper}}];
+static casadi_real *jfx_res[JFX_SZ_RES_{{ name | upper}}];
+static casadi_real *jfu_res[JFU_SZ_RES_{{ name | upper}}];
+static casadi_real *ell_res[ELL_SZ_RES_{{ name | upper}}];
+static casadi_real *ellx_res[ELLX_SZ_RES_{{ name | upper}}];
+static casadi_real *ellu_res[ELLU_SZ_RES_{{ name | upper}}];
+static casadi_real *vf_res[VF_SZ_RES_{{ name | upper}}];
+static casadi_real *vfx_res[VFX_SZ_RES_{{ name | upper}}];
+
+
+/* ------------------------------------ */
+/*      Persistent (x, u, d) memory     */
+/* ------------------------------------ */
+#define N_PERSISTENT_MEM_{{ name | upper}} (2 * NX_{{ name | upper}} + NU_{{ name | upper}})
+static casadi_real persistent_memory[N_PERSISTENT_MEM_{{ name | upper}}];  /* (x, u, d) */
+#define IDX_X_{{ name | upper}} 0
+#define IDX_U_{{ name | upper}} IDX_X_{{ name | upper}} + NX_{{ name | upper}}
+#define IDX_D_{{ name | upper}} IDX_U_{{ name | upper}} + NU_{{ name | upper}}
+
+
+void init_interface_{{ name }}(void) {
+    /* nothing */
+}
+
+/* Copy (x) into persistent_memory; arg = {x}  */
+static void copy_x_to_persistent(const casadi_real** arg) {
+    unsigned int i;
+    for (i=0; i<NX_{{ name | upper}}; i++)  
+        persistent_memory[IDX_X_{{ name | upper}} + i] = arg[0][i];  /* copy x */    
+}
+
+/* Copy (x, u) into persistent_memory; arg = {x, u}  */
+static void copy_xu_to_persistent(const casadi_real** arg) {
+    unsigned int i;
+    copy_x_to_persistent(arg);  /* copy x */
+    for (i=0; i<NU_{{ name | upper}}; i++)  
+        persistent_memory[IDX_U_{{ name | upper}} + i] = arg[1][i];  /* copy u */    
+}
+
+/* Copy (x, u, d) into persistent_memory; arg = {x, u, d}  */
+static void copy_xud_to_persistent(const casadi_real** arg) {
+    unsigned int i;
+    copy_xu_to_persistent(arg);
+    for (i=0; i<NX_{{ name | upper}}; i++)  
+        persistent_memory[IDX_D_{{ name | upper}} + i] = arg[2][i];  /* copy d */    
+}
+
+int {{ name }}_f(const casadi_real** arg, casadi_real** res) {
+    copy_xu_to_persistent(arg);  /* arg = {x, u} */
+    const casadi_real* args__[F_SZ_ARG_{{ name | upper}}] = {
+        persistent_memory + IDX_X_{{ name | upper}},
+        persistent_memory + IDX_U_{{ name | upper}}};
+    f_res[0] = res[0];
+    return casadi_{{ name }}_f(args__, f_res, iws_f, ws_f, 0);
+}
+
+int {{ name }}_jfx(const casadi_real** arg, casadi_real** res) {
+    copy_xud_to_persistent(arg);  /* arg = {x, u, d} */
+    const casadi_real* args__[JFX_SZ_ARG_{{ name | upper}}] = {
+        persistent_memory + IDX_X_{{ name | upper}},
+        persistent_memory + IDX_U_{{ name | upper}},
+        persistent_memory + IDX_D_{{ name | upper}}};
+    jfx_res[0] = res[0];
+    return casadi_{{ name }}_jfx(args__, jfx_res, iws_jfx, ws_jfx, 0);
+}
+
+int {{ name }}_jfu(const casadi_real** arg, casadi_real** res) {
+    copy_xud_to_persistent(arg);  /* arg = {x, u, d} */
+    const casadi_real* args__[JFU_SZ_ARG_{{ name | upper}}] = {
+        persistent_memory + IDX_X_{{ name | upper}},
+        persistent_memory + IDX_U_{{ name | upper}},
+        persistent_memory + IDX_D_{{ name | upper}}};
+    jfu_res[0] = res[0];
+    return casadi_{{ name }}_jfu(args__, jfu_res, iws_jfu, ws_jfu, 0);
+}
+
+int {{ name }}_ellx(const casadi_real** arg, casadi_real** res) {
+    copy_xu_to_persistent(arg);  /* arg = {x, u} */
+    const casadi_real* args__[ELLX_SZ_ARG_{{ name | upper}}] = {
+        persistent_memory + IDX_X_{{ name | upper}},
+        persistent_memory + IDX_U_{{ name | upper}}};
+    ellx_res[0] = res[0];
+    return casadi_{{ name }}_ellx(args__, ellx_res, iws_ellx, ws_ellx, 0);
+}
+
+int {{ name }}_ellu(const casadi_real** arg, casadi_real** res) {
+    copy_xu_to_persistent(arg);  /* arg = {x, u} */
+    const casadi_real* args__[ELLU_SZ_ARG_{{ name | upper}}] = {
+        persistent_memory + IDX_X_{{ name | upper}},
+        persistent_memory + IDX_U_{{ name | upper}}};
+    ellu_res[0] = res[0];
+    return casadi_{{ name }}_ellu(args__, ellu_res, iws_ellu, ws_ellu, 0);
+}
+
+int {{ name }}_vfx(const casadi_real** arg, casadi_real** res) {
+    copy_x_to_persistent(arg);  /* arg = {x} */
+    const casadi_real* args__[VFX_SZ_ARG_{{ name | upper}}] = {persistent_memory + IDX_X_{{ name | upper}}};
+    vfx_res[0] = res[0];
+    return casadi_{{ name }}_vfx(args__, vfx_res, iws_vfx, ws_vfx, 0);
+}
+
+#ifdef TEST_INTERFACE
+/* -------------------------- */
+/*           Testing          */
+/* -------------------------- */
+
+void call_f_test(){
+    double x[NX_{{ name | upper}}] = {1.570796326794897, 10., 2.};
+    double u[NU_{{ name | upper}}] = {1.5, 2.1};
+    double x_next[NX_{{ name | upper}}];
+    const double *arg[2] = {x, u};
+    double *res[1] = {x_next};
+    {{ name }}_f(arg, res);
+
+    int i;
+    for (i = 0; i < NX_{{ name | upper}}; i++)
+    {
+        printf("x+ >> %g\n", x_next[i]);
+    }
+}
+
+void call_jfx_test()
+{
+    double x[NX_{{ name | upper}}] = {1.570796326794897, 10., 2.};
+    double u[NU_{{ name | upper}}] = {1.5, 2.1};
+    double d[NX_{{ name | upper}}] = {0, 1, 0};
+
+    double jfx[NX_{{ name | upper}}];
+    const double *arg[3] = {x, u, d};
+    double *res[1] = {jfx};
+    {{ name }}_jfx(arg, res);
+
+    for (unsigned int i = 0; i < NX_{{ name | upper}}; i++)
+    {
+        printf("Jxf >> %g\n", jfx_res[0][i]);
+    }
+}
+
+void call_jfu_test()
+{
+    double x[NX_{{ name | upper}}] = {1.570796326794897, 10., 2.};
+    double u[NU_{{ name | upper}}] = {1.5, 2.1};
+    double d[NX_{{ name | upper}}] = {1, 1, 0};
+
+    double jfu[NX_{{ name | upper}}];
+    const double *arg[3] = {x, u, d};
+    double *res[1] = {jfu};
+    {{ name }}_jfu(arg, res);
+
+    for (unsigned int i = 0; i < NX_{{ name | upper}}; i++)
+    {
+        printf("Juf >> %g\n", jfu_res[0][i]);
+    }
+}
+
+void call_ellx_test()
+{
+    double x[NX_{{ name | upper}}] = {1.570796326794897, 10., 2.};
+    double u[NU_{{ name | upper}}] = {1.5, 2.1};
+
+    double ellx[NX_{{ name | upper}}];
+    const double *arg[2] = {x, u};
+    double *res[1] = {ellx};
+    {{ name }}_ellx(arg, res);
+
+    for (unsigned int i = 0; i < NX_{{ name | upper}}; i++)
+    {
+        printf("ell_x >> %g\n", ellx_res[0][i]);
+    }
+}
+
+void call_vfx_test()
+{
+    double x[NX_{{ name | upper}}] = {1.570796326794897, 10., 2.};
+
+    double vfx[NX_{{ name | upper}}];
+    const double *arg[1] = {x};
+    double *res[1] = {vfx};
+    {{ name }}_vfx(arg, res);
+
+    for (unsigned int i = 0; i < NX_{{ name | upper}}; i++)
+    {
+        printf("vfx >> %g\n", vfx_res[0][i]);
+    }
+}
+
+/* for testing purposes only! */
+int main()
+{
+    call_f_test();
+    call_jfx_test();
+    call_jfu_test();
+    call_ellx_test();
+    call_vfx_test();
+    return 0;
+}   
+#endif
+

gradgen-0.1.0/gradgen/templates/c/global_header.h.tmpl

@@ -0,0 +1,66 @@
+/*
+ * Header file with sizes of arrays that need to be allocated
+ * (statically) once
+ *
+ *
+ * This file is autogenerated by Gradgen
+ *
+ * Metadata:
+ *  + name: {{ name }}
+ *
+ */
+
+#pragma once
+
+#define NPRED_{{ name | upper}} {{ N }}
+#define NX_{{ name | upper}} {{ nx }}
+#define NU_{{ name | upper}} {{ nu }}
+
+/* f */
+#define F_SZ_ARG_{{ name | upper}} {{ f.sz_arg() }}
+#define F_SZ_IW_{{ name | upper}} {{ f.sz_iw() }}
+#define F_SZ_W_{{ name | upper}} {{ f.sz_w() }}
+#define F_SZ_RES_{{ name | upper}} {{ f.sz_res() }}
+
+/* jfx */
+#define JFX_SZ_ARG_{{ name | upper}} {{ jfx.sz_arg() }}
+#define JFX_SZ_IW_{{ name | upper}} {{ jfx.sz_iw() }}
+#define JFX_SZ_W_{{ name | upper}} {{ jfx.sz_w() }}
+#define JFX_SZ_RES_{{ name | upper}} {{ jfx.sz_res() }}
+
+/* jfu */
+#define JFU_SZ_ARG_{{ name | upper}} {{ jfu.sz_arg() }}
+#define JFU_SZ_IW_{{ name | upper}} {{ jfu.sz_iw() }}
+#define JFU_SZ_W_{{ name | upper}} {{ jfu.sz_w() }}
+#define JFU_SZ_RES_{{ name | upper}} {{ jfu.sz_res() }}
+
+/* ell */
+#define ELL_SZ_ARG_{{ name | upper}} {{ ell.sz_arg() }}
+#define ELL_SZ_IW_{{ name | upper}} {{ ell.sz_iw() }}
+#define ELL_SZ_W_{{ name | upper}} {{ ell.sz_w() }}
+#define ELL_SZ_RES_{{ name | upper}} {{ ell.sz_res() }}
+
+/* ellx */
+#define ELLX_SZ_ARG_{{ name | upper}} {{ ellx.sz_arg() }}
+#define ELLX_SZ_IW_{{ name | upper}} {{ ellx.sz_iw() }}
+#define ELLX_SZ_W_{{ name | upper}} {{ ellx.sz_w() }}
+#define ELLX_SZ_RES_{{ name | upper}} {{ ellx.sz_res() }}
+
+/* ellu */
+#define ELLU_SZ_ARG_{{ name | upper}} {{ ellu.sz_arg() }}
+#define ELLU_SZ_IW_{{ name | upper}} {{ ellu.sz_iw() }}
+#define ELLU_SZ_W_{{ name | upper}} {{ ellu.sz_w() }}
+#define ELLU_SZ_RES_{{ name | upper}} {{ ellu.sz_res() }}
+
+/* vf */
+#define VF_SZ_ARG_{{ name | upper}} {{ vf.sz_arg() }}
+#define VF_SZ_IW_{{ name | upper}} {{ vf.sz_iw() }}
+#define VF_SZ_W_{{ name | upper}} {{ vf.sz_w() }}
+#define VF_SZ_RES_{{ name | upper}} {{ vf.sz_res() }}
+
+/* vfx */
+#define VFX_SZ_ARG_{{ name | upper}} {{ vfx.sz_arg() }}
+#define VFX_SZ_IW_{{ name | upper}} {{ vfx.sz_iw() }}
+#define VFX_SZ_W_{{ name | upper}} {{ vfx.sz_w() }}
+#define VFX_SZ_RES_{{ name | upper}} {{ vfx.sz_res() }}
+

gradgen-0.1.0/gradgen/templates/casadi-rs/Cargo.toml

@@ -0,0 +1,33 @@
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Autogenerated Cargo.toml configuration file
+# This file was generated by GradGen
+#
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+[package]
+authors = ["GradGen"]
+name = "casadi_{{name}}"
+categories = [
+    "api-bindings",
+    "no-std",
+    "science",
+    "science::robotics",
+    "simulation",
+]
+keywords = ["casadi", "optimization", "interface"]
+description = "Rust interface to CasADi functions"
+license = "MIT"
+version = "0.2.1"
+edition = "2018"
+
+[dependencies]
+libc = { version = "0.2.0", default-features = false }
+
+[build-dependencies]
+cc = "1.0"
+
+[profile.dev]
+opt-level = 0
+
+[profile.release]
+opt-level = 3

gradgen-0.1.0/gradgen/templates/casadi-rs/build.rs

@@ -0,0 +1,27 @@
+use std::path::Path;
+
+fn main() {
+    assert!(
+        Path::new("extern/casadi_functions.c").exists(),
+        "extern/casadi_functions.c is missing"
+    );
+    assert!(
+        Path::new("extern/interface.c").exists(),
+        "extern/interface.c is missing"
+    );
+
+    cc::Build::new()
+        .flag_if_supported("-Wall")
+        .flag_if_supported("-Wno-unused-variable")
+        .flag_if_supported("-Wno-long-long")
+        .flag_if_supported("-Wno-unused-parameter")
+        .pic(true)
+        .include("src")
+        .file("extern/casadi_functions.c")
+        .file("extern/interface.c")
+        .compile("icasadi");
+
+    // Rerun if these autogenerated files change
+    println!("cargo:rerun-if-changed=extern/casadi_functions.c");
+    println!("cargo:rerun-if-changed=extern/interface.c");
+}

gradgen-0.1.0/gradgen/templates/casadi-rs/lib.rs

@@ -0,0 +1,123 @@
+use libc::{c_double, c_int};
+
+/// number of states 
+pub const NX: usize = {{ nx }};
+/// number of inputs
+pub const NU: usize = {{ nu }};
+/// prediction horizon
+pub const NPRED: usize = {{ N }};
+
+
+extern "C" {
+    fn init_interface_{{name}}();
+
+    fn {{name}}_f(arg: *const *const c_double, casadi_results: *mut *mut c_double) -> c_int;        
+    fn {{name}}_jfx(arg: *const *const c_double, casadi_results: *mut *mut c_double) -> c_int;
+    fn {{name}}_jfu(arg: *const *const c_double, casadi_results: *mut *mut c_double) -> c_int;
+    fn {{name}}_ellx(arg: *const *const c_double, casadi_results: *mut *mut c_double) -> c_int;
+    fn {{name}}_ellu(arg: *const *const c_double, casadi_results: *mut *mut c_double) -> c_int;
+    fn {{name}}_vfx(arg: *const *const c_double, casadi_results: *mut *mut c_double) -> c_int;
+}
+
+
+pub fn init_{{name}}() {
+    unsafe {
+        init_interface_{{name}}();
+    }
+}
+
+pub fn f(x: &[f64], u: &[f64], fxu: &mut [f64]) -> i32 {
+    let arguments = &[x.as_ptr(), u.as_ptr()];
+    let result = &mut [fxu.as_mut_ptr()];
+    unsafe { {{name}}_f(arguments.as_ptr(), result.as_mut_ptr()) as i32}
+}
+
+pub fn jfx(x: &[f64], u: &[f64], d: &[f64], jfxd: &mut [f64]) -> i32 {
+    let arguments = &[x.as_ptr(), u.as_ptr(), d.as_ptr()];
+    let result = &mut [jfxd.as_mut_ptr()];
+    unsafe { {{name}}_jfx(arguments.as_ptr(), result.as_mut_ptr()) as i32 }
+}
+
+pub fn jfu(x: &[f64], u: &[f64], d: &[f64], jfud: &mut [f64]) -> i32 {
+    let arguments = &[x.as_ptr(), u.as_ptr(), d.as_ptr()];
+    let result = &mut [jfud.as_mut_ptr()];
+    unsafe { {{name}}_jfu(arguments.as_ptr(), result.as_mut_ptr()) as i32 }
+}
+
+pub fn ellx(x: &[f64], u: &[f64], ellx_out: &mut [f64]) -> i32 {
+    let arguments = &[x.as_ptr(), u.as_ptr()];
+    let result = &mut [ellx_out.as_mut_ptr()];
+    unsafe { {{name}}_ellx(arguments.as_ptr(), result.as_mut_ptr()) as i32 }
+}
+
+pub fn ellu(x: &[f64], u: &[f64], ellu_out: &mut [f64]) -> i32 {
+    let arguments = &[x.as_ptr(), u.as_ptr()];
+    let result = &mut [ellu_out.as_mut_ptr()];
+    unsafe { {{name}}_ellu(arguments.as_ptr(), result.as_mut_ptr()) as i32 }
+}
+
+pub fn vfx(x: &[f64], vfx_out: &mut [f64]) -> i32 {
+    let arguments = &[x.as_ptr()];
+    let result = &mut [vfx_out.as_mut_ptr()];
+    unsafe { {{name}}_vfx(arguments.as_ptr(), result.as_mut_ptr()) as i32 }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn tst_init() {
+        init_{{name}}();
+    }
+
+    #[test]
+    fn tst_f(){
+        let x = [0.1; NX];
+        let u = [0.1; NU];
+        let mut fxu = [0.0; NX];
+        assert_eq!(0, f(&x, &u, &mut fxu));
+    }  
+    
+    #[test]
+    fn tst_jfx() {
+        let x = [0.1, 0.2, 0.3];
+        let u = [1.1, 2.2];
+        let d = [-0.8, 6.2, 0.0];
+        let mut jfx_d = [0.0; NX];
+        assert_eq!(0, jfx(&x, &u, &d, &mut jfx_d));
+    }
+
+    #[test]
+    fn tst_jfu() {
+        let x = [0.1, 0.2, 0.3];
+        let u = [1.1, 2.2];
+        let d = [-0.8, 6.2, 0.0];
+        let mut jfu_d = [0.0; NX];
+        assert_eq!(0, jfu(&x, &u, &d, &mut jfu_d));
+    }
+
+    #[test]
+    fn tst_ellx() {
+        let x = [0.1, 0.2, 0.3];
+        let u = [1.1, 2.2];
+        let mut ellx_res = [0.0; NX];
+        assert_eq!(0, ellx(&x, &u, &mut ellx_res));
+    }
+
+    #[test]
+    fn tst_ellu() {
+        let x = [0.1, 0.2, 0.3];
+        let u = [1.1, 2.2];
+        let mut ellu_res = [0.0; NU];
+        assert_eq!(0, ellu(&x, &u, &mut ellu_res));
+    }
+
+    #[test]
+    fn tst_vfx() {
+        let x = [0.1, 0.2, 0.3];
+        let u = [1.1, 2.2];
+        let mut vfx_res = [0.0; NX];
+        assert_eq!(0, vfx(&x, &mut vfx_res));
+    }
+}

gradgen-0.1.0/gradgen/templates/rust/Cargo.toml

@@ -0,0 +1,21 @@
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Autogenerated Cargo.toml configuration file
+# This file was generated by GradGen
+#
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+[package]
+name = "{{name}}"
+version = "0.0.0"
+license = "MIT"
+authors = ["GradGen"]
+edition = "2018"
+publish = false
+
+
+[dependencies]
+casadi_{{name}} = { path = "./casadi_{{name}}/" }
+
+
+[lib]
+crate-type = ["rlib"]

gradgen-0.1.0/gradgen/templates/rust/lib.rs

@@ -0,0 +1,117 @@
+// nothing
+use casadi_{{name}}::*;
+
+pub fn num_states() -> usize {
+    return NX;
+}
+
+pub fn num_inputs() -> usize {
+    return NU;
+}
+
+#[derive(Debug)]
+pub struct BackwardGradientWorkspace {
+    pub(crate) w: Vec<f64>,
+    pub(crate) w_new: Vec<f64>,
+    pub(crate) x_seq: Vec<f64>,
+    pub(crate) temp_nu: Vec<f64>,
+    pub(crate) temp_nx: Vec<f64>,
+}
+
+impl BackwardGradientWorkspace {
+    pub fn new(n_pred: usize) -> BackwardGradientWorkspace {
+        BackwardGradientWorkspace {
+            w: vec![0.0; NX],
+            w_new : vec![0.0; NX],
+            x_seq: vec![0.0; NX * (n_pred + 1)],
+            temp_nu: vec! [0.0; NU],
+            temp_nx: vec! [0.0; NX],
+        }
+    }
+}
+
+
+/// a = a + b
+fn add(a: &mut [f64], b: &[f64]) {
+    a.iter_mut().zip(b.iter()).for_each(|(ai, bi)| *ai += *bi);
+}
+
+
+
+pub fn total_cost_gradient_bw(
+    x0: &[f64],
+    u_seq: &[f64],
+    grad: &mut [f64],
+    workspace: &mut BackwardGradientWorkspace,
+    n: usize
+) {
+
+    /*
+    * Simulate the system sxtarting from x0 and using the
+    * sequence of inputs, u_seq = (u(0), u(1), .., U(N-1))
+    * and store the states, x_seq = (x(0), x(1),..., x(N))
+    * in workspace. x_seq = (x(0), x(1), . . . , x (N))
+    */
+    workspace.x_seq[0..NX].copy_from_slice(x0);
+    /* Simulation */
+    for t in 0..= n - 1 {
+        let xt = &workspace.x_seq[t * NX.. (t + 1) * NX];
+        let ut = &u_seq[t * NU.. (t + 1) * NU];
+        // W= f(xt, ut)
+        f(xt, ut, &mut workspace.w);
+        // x seq[next]<- W (CODY)
+        workspace.x_seq[(t + 1) * NX.. (t + 2) * NX].copy_from_slice (&workspace.w);
+    }
+
+    /* Store Vfx in w */
+    let xn = &workspace.x_seq[n * NX..(n + 1) * NX];
+    vfx(xn, &mut workspace.w);
+
+    /* backward for-loop */
+    for j in 1..=n{
+
+        let xnj = &workspace.x_seq[(n-j)* NX.. (n-j+ 1) * NX];
+        let unj = &u_seq[(n-j) * NU.. (n-j+1)* NU];
+        let gradnj = &mut grad[(n-j) * NU.. (n-j+1)* NU];
+
+        // gradnj := f^u(w) at t=N-j
+        jfu(xnj, unj, &mut workspace.w, gradnj);
+        // temp_nu := ellu at t=N-j
+        ellu(xnj, unj,&mut workspace.temp_nu );
+        // gradnj += temp_nu
+        add(gradnj, &workspace.temp_nu);
+
+
+        // gradnj += &mut workspace.temp_nx
+        jfx(xnj, unj, &mut workspace.w, &mut workspace.w_new);
+        // temp_nx <-- ell^x_N_minus_j
+        ellx(xnj, unj,&mut workspace.temp_nx );
+        // grad_V_N_minus_j += temp_nx
+        add(&mut workspace.w_new, &workspace.temp_nx);
+        workspace.w.copy_from_slice (&workspace.w_new);
+    }
+
+
+
+
+}
+
+#[cfg(test)]
+mod tests {
+
+    use casadi_{{name}}::*;
+
+    #[test]
+    fn tst_nothing() {
+        let n: usize= 6 ;
+        let mut ws = super::BackwardGradientWorkspace::new(n);
+        let x0 = vec![1.0; NX];
+        let u_seq = vec![1.0; NU * n];
+        let mut grad = vec![0.0; NU * n];
+        super::total_cost_gradient_bw(&x0, &u_seq, &mut grad, &mut ws, n);
+        println!("The gradient of total cost function is {:?}", grad);
+        println!("The state variable x is {:?}", ws.x_seq);
+    }
+}
+
+

gradgen-0.1.0/gradgen/test/test_gradgen.py

@@ -0,0 +1,62 @@
+import os
+import unittest
+import casadi.casadi as cs
+from gradgen.cost_gradient import *
+import logging
+import numpy as np
+import subprocess
+
+logger = logging.getLogger(__name__)
+
+
+class GradgenTestCase(unittest.TestCase):
+
+    @classmethod
+    def create_example(cls):
+        nx, nu = 10, 3
+        k1, k2, Ts = 252, 20, 1 / 125
+        Gamma_u = np.diag([0, 0, 124.659])
+        Gamma_n = np.diag([2.287469, 1.35699886, -0.42388942])
+        I = np.diag([0.01788, 0.03014, 0.04614])
+        Iinv = np.linalg.inv(I)
+        x = cs.SX.sym('x', nx)
+        u = cs.SX.sym('u', nu)
+        (q0, q1, q2, q3, wx, wy, wz, nx, ny, nz) = (
+            x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8], x[9])
+        Q_bar_q = cs.vertcat(cs.vertcat(0, -x[5], -x[6], -x[7]).T,
+                             cs.vertcat(x[5], 0, x[7], -x[6]).T,
+                             cs.vertcat(x[6], -x[7], 0, x[5]).T,
+                             cs.vertcat(x[7], x[6], -x[5], 0).T)
+        tau = cs.sqrt(wx ** 2 + wy ** 2 + wz ** 2)
+        expQbar = cs.vertcat(
+            cs.vertcat(cs.cosh(tau), -wx * tau, -wy * tau, -wz * tau).T,
+            cs.vertcat(wx * tau, cs.cosh(tau), wz * tau, wy * tau).T,
+            cs.vertcat(wy * tau, -wz * tau, cs.cosh(tau), wx * tau).T,
+            cs.vertcat(wz * tau, wy * tau, -wx * tau, cs.cosh(tau)).T)
+        q = cs.vertcat(q0, q1, q2, q3)
+        w = cs.vertcat(wx, wy, wz)
+        n = cs.vertcat(nx, ny, nz)
+        f = cs.vertcat((Ts / 2) * expQbar @ q,
+                       w + Ts * (Gamma_n @ n + Gamma_u @ u -
+                                 Iinv @ cs.cross(w, I @ w)),
+                       n + Ts * (k1 * k2 * u - k2 * n)
+                       )
+
+        # Stage cost function, ell
+        ell = 5*x[0]**2 + 0.01*x[1]**2 + 0.01*x[2]**2
+
+        # terminal cost function, vf
+        vf = 0.5 * (x[0]**2 + 50 * x[1]**2 + 100 * x[2]**2)
+        return x, u, f, ell, vf
+
+    def test_generate_code_and_build(self):
+        x, u, f, ell, vf = GradgenTestCase.create_example()
+        N = 15
+        gradObj = CostGradient(x, u, f, ell, vf, N).with_name(
+            "quadcopter_test").with_target_path(".")
+        gradObj.build(no_rust_build=True)
+
+
+if __name__ == '__main__':
+    logger.setLevel(logging.ERROR)
+    unittest.main()

gradgen-0.1.0/gradgen.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: gradgen
+Version: 0.1.0
+Summary: Gradient computation with AD for optimal control
+Home-page: https://github.com/alphaville/gradgen
+Author: ['Jie Lin', 'Pantelis Sopasakis']
+Author-email: p.sopasakis@gmail.com
+License: MIT License
+Keywords: optimization,nonconvex,embedded
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Rust
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Embedded Systems
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+
+# GradGen
+
+Code generation for cost gradient
+
+### Installation instructions
+
+To build this project locally:
+
+- Create a virtual environment: `virtualenv -p python3 venv`
+- Activate the virtual environment. On Linux/MacOS, run `source venv/bin/activate`
+- Install the project: `pip install .`
+
+The folder `playground` can be used during the design phase of the project to try out different things, but it should be removed for release.
+
+

gradgen-0.1.0/gradgen.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+MANIFEST.in
+README.md
+VERSION
+setup.py
+gradgen/__init__.py
+gradgen/cost_gradient.py
+gradgen/definitions.py
+gradgen.egg-info/PKG-INFO
+gradgen.egg-info/SOURCES.txt
+gradgen.egg-info/dependency_links.txt
+gradgen.egg-info/not-zip-safe
+gradgen.egg-info/requires.txt
+gradgen.egg-info/top_level.txt
+gradgen/templates/c/autograd_interface.c.tmpl
+gradgen/templates/c/global_header.h.tmpl
+gradgen/templates/casadi-rs/Cargo.toml
+gradgen/templates/casadi-rs/build.rs
+gradgen/templates/casadi-rs/lib.rs
+gradgen/templates/rust/Cargo.toml
+gradgen/templates/rust/lib.rs
+gradgen/test/__init__.py
+gradgen/test/test_gradgen.py

gradgen-0.1.0/gradgen.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gradgen-0.1.0/gradgen.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

gradgen-0.1.0/gradgen.egg-info/requires.txt

@@ -0,0 +1,3 @@
+jinja2
+casadi
+numpy

gradgen-0.1.0/gradgen.egg-info/top_level.txt

@@ -0,0 +1 @@
+gradgen

gradgen-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gradgen-0.1.0/setup.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+from setuptools import setup, find_packages
+import io
+import os
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+NAME = 'gradgen'
+
+# Import version from file
+version_file = open(os.path.join(here, 'VERSION'))
+VERSION = version_file.read().strip()
+
+DESCRIPTION = 'Gradient computation with AD for optimal control'
+
+
+# Import the README and use it as the long-description.
+# Note: this will only work if 'README.md' is present in your MANIFEST.in file!
+try:
+    with io.open(os.path.join(here, 'README.md'), encoding='utf-8') as f:
+        long_description = '\n' + f.read()
+except FileNotFoundError:
+    long_description = DESCRIPTION
+
+setup(name=NAME,
+      version=VERSION,
+      description=DESCRIPTION,
+      long_description=long_description,
+      long_description_content_type='text/markdown',
+      author=['Jie Lin', 'Pantelis Sopasakis'],
+      author_email='p.sopasakis@gmail.com',
+      license='MIT License',
+      packages=find_packages(
+          exclude=["templates", "test"]),
+      include_package_data=True,
+      install_requires=[
+          'jinja2', 'casadi', 'numpy'
+      ],
+      classifiers=[
+          'Development Status :: 4 - Beta',
+          'License :: OSI Approved :: MIT License',
+          'Programming Language :: Python',
+          'Programming Language :: Rust',
+          'Intended Audience :: Science/Research',
+          'Topic :: Software Development :: Libraries',
+          'Topic :: Scientific/Engineering',
+          'Topic :: Scientific/Engineering :: Mathematics',
+          'Topic :: Software Development :: Code Generators',
+          'Topic :: Software Development :: Embedded Systems'
+      ],
+      keywords=['optimization', 'nonconvex', 'embedded'],
+      url=(
+          'https://github.com/alphaville/gradgen'
+      ),
+      zip_safe=False)