added cpp lib

.travis.yml

@@ -3,6 +3,14 @@ python:
   - "3.5"
   - "3.6"
 # command to install dependencies
+sudo: false
+addons:
+  apt:
+    packages:
+    - libblas-dev
+    - liblapack-dev
+    - gcc
+    - gfortran
 install:
   # We do this conditionally because it saves us some downloading if the
   # version is the same.
@@ -23,12 +31,15 @@ install:
   - conda install scipy
   - conda install pandas
   - conda install scikit-learn
+  - conda install cython
   - pip install cvxopt
   - pip install cvxpy
   - pip install simpleutils
   - pip install coveralls
 script:
   - export NUMBA_DISABLE_JIT=1
+  - export LD_LIBRARY_PATH="$PWD/libs/lib/linux:$LD_LIBRARY_PATH"
+  - python build_ext --inplace
   - coverage run alphamind/tests/test_suite.py
   - coverage report
   - coverage html

alphamind/cython/lpoptimizer.pyx

+# -*- coding: utf-8 -*-
+# distutils: language = c++
+"""
+Created on 2017-7-20
+
+@author: cheng.li
+"""
+
+cimport numpy as cnp
+import numpy as np
+from libcpp.vector cimport vector
+
+
+cdef extern from "lpoptimizer.hpp" namespace "pfopt":
+    cdef cppclass LpOptimizer:
+        LpOptimizer(vector[double], vector[double], vector[double], vector[double]) except +
+        vector[double] xValue()
+        double feval()
+        int status()
+
+
+cdef class LPOptimizer:
+
+    cdef LpOptimizer* cobj
+
+    def __init__(self,
+                 cnp.ndarray[double, ndim=2] cons_matrix,
+                 cnp.ndarray[double] lbound,
+                 cnp.ndarray[double] ubound,
+                 cnp.ndarray[double] objective):
+
+        self.cobj = new LpOptimizer(cons_matrix.flatten().tolist(),
+                                    lbound,
+                                    ubound,
+                                    objective)
+
+    def __del__(self):
+        del self.cobj
+
+    def status(self):
+        return self.cobj.status()
+
+    def feval(self):
+        return self.cobj.feval()
+
+    def x_value(self):
+        return np.array(self.cobj.xValue())
\ No newline at end of file

alphamind/examples/single_day_portfolio.py

@@ -5,85 +5,24 @@ Created on 2017-5-15
 @author: cheng.li
 """
 
-import numpy as np
-import sqlalchemy
-import pandas as pd
-from alphamind.examples.config import risk_factors_500
-from alphamind.data.standardize import standardize
+import sqlalchemy as sa
+from alphamind.data.engines.sqlengine import risk_styles
+from alphamind.data.engines.sqlengine import industry_styles
+from alphamind.data.engines.sqlengine import SqlEngine
+from alphamind.data.engines.universe import Universe
 from alphamind.data.neutralize import neutralize
+from alphamind.data.standardize import standardize
 from alphamind.data.winsorize import winsorize_normal
-from alphamind.portfolio.linearbuilder import linear_build
-
-ref_date = '2017-05-11'
-
-common_factors = ['EPSAfterNonRecurring', 'DivP']
-prod_factors = ['CFinc1', 'BDTO', 'RVOL']
-
-factor_weights = 1. / np.array([15.44, 32.72, 49.90, 115.27, 97.76])
-factor_weights = factor_weights / factor_weights.sum()
-
-index_components = '500Weight'
-
-engine = sqlalchemy.create_engine('mysql+mysqldb://user:pwd@host/multifactor?charset=utf8')
-
-common_factors_df = pd.read_sql("select Date, Code, 申万一级行业, {0} from factor_data where Date = '{1}'"
-                                .format(','.join(common_factors), ref_date), engine)
-
-prod_factors_df = pd.read_sql("select Date, Code, {0} from prod_500 where Date = '{1}'"
-                              .format(','.join(prod_factors), ref_date), engine)
-
-risk_factor_df = pd.read_sql("select Date, Code, {0} from risk_factor_500 where Date = '{1}'"
-                             .format(','.join(risk_factors_500), ref_date), engine)
-
-index_components_df = pd.read_sql("select Date, Code, {0} from index_components where Date = '{1}'"
-                                  .format(index_components, ref_date), engine)
-
-total_data = pd.merge(common_factors_df, prod_factors_df, on=['Date', 'Code'])
-total_data = pd.merge(total_data, risk_factor_df, on=['Date', 'Code'])
-total_data = pd.merge(total_data, index_components_df, on=['Date', 'Code'])
-total_data = total_data[total_data[index_components] != 0]
-total_data[index_components] = total_data[index_components] / 100.0
-
-total_factors = common_factors + prod_factors
-risk_factors_names = risk_factors_500 + ['Market']
-total_data['Market'] = 1.
-
-all_factors = total_data[total_factors]
-risk_factors = total_data[risk_factors_names]
-
-factor_processed = neutralize(risk_factors.values,
-                              standardize(winsorize_normal(all_factors.values)))
-
-normed_factor = pd.DataFrame(factor_processed, columns=total_factors, index=total_data.Date)
-
-er = normed_factor @ factor_weights
-
-# portfolio construction
-
-bm = total_data[index_components].values
-lbound = 0.
-ubound = 0.01 + bm
-lbound_exposure = -0.01
-ubound_exposure = 0.01
-risk_exposure = total_data[risk_factors_names].values
-
-status, value, ret = linear_build(er,
-                                  lbound=lbound,
-                                  ubound=ubound,
-                                  risk_exposure=risk_exposure,
-                                  bm=bm,
-                                  risk_target=(lbound_exposure, ubound_exposure),
-                                  solver='GLPK')
-
-if status != 'optimal':
-    raise ValueError('target is not feasible')
-else:
-    portfolio = pd.DataFrame({'weight': ret,
-                              'industry': total_data['申万一级行业'].values,
-                              'zz500': total_data[index_components].values}, index=total_data.Code)
-
-    portfolio.to_csv(r'\\10.63.6.71\sharespace\personal\licheng\portfolio\zz500\{0}.csv'.format(ref_date))
+from PyFin.api import bizDatesList
 
 
+universe = Universe("zz500", ['zz500'])
+engine = SqlEngine("mysql+pymysql://root:we083826@localhost/alpha?charset=utf8")
+dates = bizDatesList('china.sse', '2017-01-01', '2017-07-10')
 
+for date in dates:
+    print(date)
+    ref_date = date.strftime("%Y-%m-%d")
 
+    codes = engine.fetch_codes(ref_date, universe)
+    engine.fetch_data(ref_date, ['EPS'], codes)
\ No newline at end of file

libs/include/alglib/CMakeLists.txt

+file(GLOB_RECURSE ALGLIB_FILES ".h" "*.hpp" "*.cpp")
+
+add_library(alglib ${LIB_TYPE} ${ALGLIB_FILES})

libs/include/alglib/diffequations.h

+/*************************************************************************
+ALGLIB 3.11.0 (source code generated 2017-05-11)
+Copyright (c) Sergey Bochkanov (ALGLIB project).
+
+>>> SOURCE LICENSE >>>
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation (www.fsf.org); either version 2 of the 
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+A copy of the GNU General Public License is available at
+http://www.fsf.org/licensing/licenses
+>>> END OF LICENSE >>>
+*************************************************************************/
+#ifndef _diffequations_pkg_h
+#define _diffequations_pkg_h
+#include "ap.h"
+#include "alglibinternal.h"
+
+/////////////////////////////////////////////////////////////////////////
+//
+// THIS SECTION CONTAINS COMPUTATIONAL CORE DECLARATIONS (DATATYPES)
+//
+/////////////////////////////////////////////////////////////////////////
+namespace alglib_impl
+{
+typedef struct
+{
+    ae_int_t n;
+    ae_int_t m;
+    double xscale;
+    double h;
+    double eps;
+    ae_bool fraceps;
+    ae_vector yc;
+    ae_vector escale;
+    ae_vector xg;
+    ae_int_t solvertype;
+    ae_bool needdy;
+    double x;
+    ae_vector y;
+    ae_vector dy;
+    ae_matrix ytbl;
+    ae_int_t repterminationtype;
+    ae_int_t repnfev;
+    ae_vector yn;
+    ae_vector yns;
+    ae_vector rka;
+    ae_vector rkc;
+    ae_vector rkcs;
+    ae_matrix rkb;
+    ae_matrix rkk;
+    rcommstate rstate;
+} odesolverstate;
+typedef struct
+{
+    ae_int_t nfev;
+    ae_int_t terminationtype;
+} odesolverreport;
+
+}
+
+/////////////////////////////////////////////////////////////////////////
+//
+// THIS SECTION CONTAINS C++ INTERFACE
+//
+/////////////////////////////////////////////////////////////////////////
+namespace alglib
+{
+
+/*************************************************************************
+
+*************************************************************************/
+class _odesolverstate_owner
+{
+public:
+    _odesolverstate_owner();
+    _odesolverstate_owner(const _odesolverstate_owner &rhs);
+    _odesolverstate_owner& operator=(const _odesolverstate_owner &rhs);
+    virtual ~_odesolverstate_owner();
+    alglib_impl::odesolverstate* c_ptr();
+    alglib_impl::odesolverstate* c_ptr() const;
+protected:
+    alglib_impl::odesolverstate *p_struct;
+};
+class odesolverstate : public _odesolverstate_owner
+{
+public:
+    odesolverstate();
+    odesolverstate(const odesolverstate &rhs);
+    odesolverstate& operator=(const odesolverstate &rhs);
+    virtual ~odesolverstate();
+    ae_bool &needdy;
+    real_1d_array y;
+    real_1d_array dy;
+    double &x;
+
+};
+
+
+/*************************************************************************
+
+*************************************************************************/
+class _odesolverreport_owner
+{
+public:
+    _odesolverreport_owner();
+    _odesolverreport_owner(const _odesolverreport_owner &rhs);
+    _odesolverreport_owner& operator=(const _odesolverreport_owner &rhs);
+    virtual ~_odesolverreport_owner();
+    alglib_impl::odesolverreport* c_ptr();
+    alglib_impl::odesolverreport* c_ptr() const;
+protected:
+    alglib_impl::odesolverreport *p_struct;
+};
+class odesolverreport : public _odesolverreport_owner
+{
+public:
+    odesolverreport();
+    odesolverreport(const odesolverreport &rhs);
+    odesolverreport& operator=(const odesolverreport &rhs);
+    virtual ~odesolverreport();
+    ae_int_t &nfev;
+    ae_int_t &terminationtype;
+
+};
+
+/*************************************************************************
+Cash-Karp adaptive ODE solver.
+
+This subroutine solves ODE  Y'=f(Y,x)  with  initial  conditions  Y(xs)=Ys
+(here Y may be single variable or vector of N variables).
+
+INPUT PARAMETERS:
+    Y       -   initial conditions, array[0..N-1].
+                contains values of Y[] at X[0]
+    N       -   system size
+    X       -   points at which Y should be tabulated, array[0..M-1]
+                integrations starts at X[0], ends at X[M-1],  intermediate
+                values at X[i] are returned too.
+                SHOULD BE ORDERED BY ASCENDING OR BY DESCENDING!
+    M       -   number of intermediate points + first point + last point:
+                * M>2 means that you need both Y(X[M-1]) and M-2 values at
+                  intermediate points
+                * M=2 means that you want just to integrate from  X[0]  to
+                  X[1] and don't interested in intermediate values.
+                * M=1 means that you don't want to integrate :)
+                  it is degenerate case, but it will be handled correctly.
+                * M<1 means error
+    Eps     -   tolerance (absolute/relative error on each  step  will  be
+                less than Eps). When passing:
+                * Eps>0, it means desired ABSOLUTE error
+                * Eps<0, it means desired RELATIVE error.  Relative errors
+                  are calculated with respect to maximum values of  Y seen
+                  so far. Be careful to use this criterion  when  starting
+                  from Y[] that are close to zero.
+    H       -   initial  step  lenth,  it  will  be adjusted automatically
+                after the first  step.  If  H=0,  step  will  be  selected
+                automatically  (usualy  it  will  be  equal  to  0.001  of
+                min(x[i]-x[j])).
+
+OUTPUT PARAMETERS
+    State   -   structure which stores algorithm state between  subsequent
+                calls of OdeSolverIteration. Used for reverse communication.
+                This structure should be passed  to the OdeSolverIteration
+                subroutine.
+
+SEE ALSO
+    AutoGKSmoothW, AutoGKSingular, AutoGKIteration, AutoGKResults.
+
+
+  -- ALGLIB --
+     Copyright 01.09.2009 by Bochkanov Sergey
+*************************************************************************/
+void odesolverrkck(const real_1d_array &y, const ae_int_t n, const real_1d_array &x, const ae_int_t m, const double eps, const double h, odesolverstate &state);
+void odesolverrkck(const real_1d_array &y, const real_1d_array &x, const double eps, const double h, odesolverstate &state);
+
+
+/*************************************************************************
+This function provides reverse communication interface
+Reverse communication interface is not documented or recommended to use.
+See below for functions which provide better documented API
+*************************************************************************/
+bool odesolveriteration(const odesolverstate &state);
+
+
+/*************************************************************************
+This function is used to launcn iterations of ODE solver
+
+It accepts following parameters:
+    diff    -   callback which calculates dy/dx for given y and x
+    ptr     -   optional pointer which is passed to diff; can be NULL
+
+
+  -- ALGLIB --
+     Copyright 01.09.2009 by Bochkanov Sergey
+
+*************************************************************************/
+void odesolversolve(odesolverstate &state,
+    void (*diff)(const real_1d_array &y, double x, real_1d_array &dy, void *ptr),
+    void *ptr = NULL);
+
+
+/*************************************************************************
+ODE solver results
+
+Called after OdeSolverIteration returned False.
+
+INPUT PARAMETERS:
+    State   -   algorithm state (used by OdeSolverIteration).
+
+OUTPUT PARAMETERS:
+    M       -   number of tabulated values, M>=1
+    XTbl    -   array[0..M-1], values of X
+    YTbl    -   array[0..M-1,0..N-1], values of Y in X[i]
+    Rep     -   solver report:
+                * Rep.TerminationType completetion code:
+                    * -2    X is not ordered  by  ascending/descending  or
+                            there are non-distinct X[],  i.e.  X[i]=X[i+1]
+                    * -1    incorrect parameters were specified
+                    *  1    task has been solved
+                * Rep.NFEV contains number of function calculations
+
+  -- ALGLIB --
+     Copyright 01.09.2009 by Bochkanov Sergey
+*************************************************************************/
+void odesolverresults(const odesolverstate &state, ae_int_t &m, real_1d_array &xtbl, real_2d_array &ytbl, odesolverreport &rep);
+}
+
+/////////////////////////////////////////////////////////////////////////
+//
+// THIS SECTION CONTAINS COMPUTATIONAL CORE DECLARATIONS (FUNCTIONS)
+//
+/////////////////////////////////////////////////////////////////////////
+namespace alglib_impl
+{
+void odesolverrkck(/* Real    */ ae_vector* y,
+     ae_int_t n,
+     /* Real    */ ae_vector* x,
+     ae_int_t m,
+     double eps,
+     double h,
+     odesolverstate* state,
+     ae_state *_state);
+ae_bool odesolveriteration(odesolverstate* state, ae_state *_state);
+void odesolverresults(odesolverstate* state,
+     ae_int_t* m,
+     /* Real    */ ae_vector* xtbl,
+     /* Real    */ ae_matrix* ytbl,
+     odesolverreport* rep,
+     ae_state *_state);
+void _odesolverstate_init(void* _p, ae_state *_state);
+void _odesolverstate_init_copy(void* _dst, void* _src, ae_state *_state);
+void _odesolverstate_clear(void* _p);
+void _odesolverstate_destroy(void* _p);
+void _odesolverreport_init(void* _p, ae_state *_state);
+void _odesolverreport_init_copy(void* _dst, void* _src, ae_state *_state);
+void _odesolverreport_clear(void* _p);
+void _odesolverreport_destroy(void* _p);
+
+}
+#endif
+

libs/include/alglib/stdafx.h

+
+

libs/include/clp/ClpConfig.h

+/* src/config_clp.h.  Generated by configure.  */
+/* src/config_clp.h.in.  */
+
+/* Define to 1, 2, 3, or 4 if Aboca should be build. */
+/* #undef CLP_HAS_ABC */
+
+/* Version number of project */
+#define CLP_VERSION "1.16"
+
+/* Major Version number of project */
+#define CLP_VERSION_MAJOR 1
+
+/* Minor Version number of project */
+#define CLP_VERSION_MINOR 16
+
+/* Release Version number of project */
+#define CLP_VERSION_RELEASE 9999

libs/include/clp/ClpConstraint.hpp

+/* $Id: ClpConstraint.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2007, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpConstraint_H
+#define ClpConstraint_H
+
+
+//#############################################################################
+class ClpSimplex;
+class ClpModel;
+
+/** Constraint Abstract Base Class
+
+Abstract Base Class for describing a constraint or objective function
+
+*/
+class ClpConstraint  {
+
+public:
+
+     ///@name Stuff
+     //@{
+
+     /** Fills gradient.  If Linear then solution may be NULL,
+         also returns true value of function and offset so we can use x not deltaX in constraint
+         If refresh is false then uses last solution
+         Uses model for scaling
+         Returns non-zero if gradient undefined at current solution
+     */
+     virtual int gradient(const ClpSimplex * model,
+                          const double * solution,
+                          double * gradient,
+                          double & functionValue ,
+                          double & offset,
+                          bool useScaling = false,
+                          bool refresh = true) const = 0;
+     /// Constraint function value
+     virtual double functionValue (const ClpSimplex * model,
+                                   const double * solution,
+                                   bool useScaling = false,
+                                   bool refresh = true) const ;
+     /// Resize constraint
+     virtual void resize(int newNumberColumns) = 0;
+     /// Delete columns in  constraint
+     virtual void deleteSome(int numberToDelete, const int * which) = 0;
+     /// Scale constraint
+     virtual void reallyScale(const double * columnScale) = 0;
+     /** Given a zeroed array sets nonlinear columns to 1.
+         Returns number of nonlinear columns
+      */
+     virtual int markNonlinear(char * which) const = 0;
+     /** Given a zeroed array sets possible nonzero coefficients to 1.
+         Returns number of nonzeros
+      */
+     virtual int markNonzero(char * which) const = 0;
+     //@}
+
+
+     ///@name Constructors and destructors
+     //@{
+     /// Default Constructor
+     ClpConstraint();
+
+     /// Copy constructor
+     ClpConstraint(const ClpConstraint &);
+
+     /// Assignment operator
+     ClpConstraint & operator=(const ClpConstraint& rhs);
+
+     /// Destructor
+     virtual ~ClpConstraint ();
+
+     /// Clone
+     virtual ClpConstraint * clone() const = 0;
+
+     //@}
+
+     ///@name Other
+     //@{
+     /// Returns type, 0 linear, 1 nonlinear
+     inline int type() {
+          return type_;
+     }
+     /// Row number (-1 is objective)
+     inline int rowNumber() const {
+          return rowNumber_;
+     }
+
+     /// Number of possible coefficients in gradient
+     virtual int numberCoefficients() const = 0;
+
+     /// Stored constraint function value
+     inline double functionValue () const {
+          return functionValue_;
+     }
+
+     /// Constraint offset
+     inline double offset () const {
+          return offset_;
+     }
+     /// Say we have new primal solution - so may need to recompute
+     virtual void newXValues() {}
+     //@}
+
+     //---------------------------------------------------------------------------
+
+protected:
+     ///@name Protected member data
+     //@{
+     /// Gradient at last evaluation
+     mutable double * lastGradient_;
+     /// Value of non-linear part of constraint
+     mutable double functionValue_;
+     /// Value of offset for constraint
+     mutable double offset_;
+     /// Type of constraint - linear is 1
+     int type_;
+     /// Row number (-1 is objective)
+     int rowNumber_;
+     //@}
+};
+
+#endif