refactor name

alphamind/analysis/factoranalysis.py

@@ -16,7 +16,7 @@ from alphamind.portfolio.constraints import Constraints
 from alphamind.portfolio.constraints import LinearConstraints
 from alphamind.portfolio.longshortbulder import long_short_build
 from alphamind.portfolio.rankbuilder import rank_build
-from alphamind.portfolio.linearbuilder import linear_build
+from alphamind.portfolio.linearbuilder import linear_builder
 from alphamind.portfolio.meanvariancebuilder import mean_variance_builder
 from alphamind.portfolio.meanvariancebuilder import target_vol_builder
 from alphamind.data.processing import factor_processing
@@ -95,13 +95,13 @@ def er_portfolio_analysis(er: np.ndarray,
         turn_over_target = kwargs.get('turn_over_target')
         current_position = kwargs.get('current_position')
 
-        status, _, weights = linear_build(er,
-                                          risk_constraints=cons_exp,
-                                          lbound=lbound,
-                                          ubound=ubound,
-                                          risk_target=(risk_lbound, risk_ubound),
-                                          turn_over_target=turn_over_target,
-                                          current_position=current_position)
+        status, _, weights = linear_builder(er,
+                                            risk_constraints=cons_exp,
+                                            lbound=lbound,
+                                            ubound=ubound,
+                                            risk_target=(risk_lbound, risk_ubound),
+                                            turn_over_target=turn_over_target,
+                                            current_position=current_position)
         if status != 'optimal':
             raise ValueError('linear programming optimizer in status: {0}'.format(status))
 

alphamind/benchmarks/portfolio/linearbuild.py

@@ -10,7 +10,7 @@ import numpy as np
 from scipy.optimize import linprog
 from cvxopt import matrix
 from cvxopt import solvers
-from alphamind.portfolio.linearbuilder import linear_build
+from alphamind.portfolio.linearbuilder import linear_builder
 
 solvers.options['show_progress'] = False
 
@@ -33,11 +33,11 @@ def benchmark_build_linear(n_samples: int, n_risks: int, n_loop: int) -> None:
 
     start = dt.datetime.now()
     for _ in range(n_loop):
-        status, v, x = linear_build(er,
-                                    lbound,
-                                    ubound,
-                                    risk_exp,
-                                    risk_target=(risk_lbound,
+        status, v, x = linear_builder(er,
+                                      lbound,
+                                      ubound,
+                                      risk_exp,
+                                      risk_target=(risk_lbound,
                                                  risk_ubound))
     impl_model_time = dt.datetime.now() - start
     print('{0:20s}: {1}'.format('Implemented model (ECOS)', impl_model_time))

alphamind/portfolio/linearbuilder.py

@@ -11,13 +11,13 @@ from typing import Union
 from alphamind.cython.optimizers import LPOptimizer
 
 
-def linear_build(er: np.ndarray,
-                 lbound: Union[np.ndarray, float],
-                 ubound: Union[np.ndarray, float],
-                 risk_constraints: np.ndarray,
-                 risk_target: Tuple[np.ndarray, np.ndarray],
-                 turn_over_target: float = None,
-                 current_position: np.ndarray = None) -> Tuple[str, np.ndarray, np.ndarray]:
+def linear_builder(er: np.ndarray,
+                   lbound: Union[np.ndarray, float],
+                   ubound: Union[np.ndarray, float],
+                   risk_constraints: np.ndarray,
+                   risk_target: Tuple[np.ndarray, np.ndarray],
+                   turn_over_target: float = None,
+                   current_position: np.ndarray = None) -> Tuple[str, np.ndarray, np.ndarray]:
     er = er.flatten()
     n, m = risk_constraints.shape
 
@@ -100,13 +100,13 @@ if __name__ == '__main__':
     risk_lbound = np.ones(1)
     risk_ubound = np.ones(1)
 
-    status, fvalue, x_values = linear_build(er,
-                                            lb,
-                                            ub,
-                                            cons,
-                                            (risk_lbound, risk_ubound),
-                                            turn_over_target,
-                                            current_pos)
+    status, fvalue, x_values = linear_builder(er,
+                                              lb,
+                                              ub,
+                                              cons,
+                                              (risk_lbound, risk_ubound),
+                                              turn_over_target,
+                                              current_pos)
 
     print(status)
     print(fvalue)

alphamind/tests/portfolio/test_linearbuild.py

@@ -7,7 +7,7 @@ Created on 2017-5-5
 
 import unittest
 import numpy as np
-from alphamind.portfolio.linearbuilder import linear_build
+from alphamind.portfolio.linearbuilder import linear_builder
 
 
 class TestLinearBuild(unittest.TestCase):
@@ -23,11 +23,11 @@ class TestLinearBuild(unittest.TestCase):
         bm = self.bm / self.bm.sum()
         eplson = 1e-6
 
-        status, _, w = linear_build(self.er,
-                                    0.,
-                                    0.01,
-                                    self.risk_exp,
-                                    (bm @ self.risk_exp, bm @ self.risk_exp))
+        status, _, w = linear_builder(self.er,
+                                      0.,
+                                      0.01,
+                                      self.risk_exp,
+                                      (bm @ self.risk_exp, bm @ self.risk_exp))
         self.assertEqual(status, 'optimal')
         self.assertAlmostEqual(np.sum(w), 1.)
         self.assertTrue(np.all(w <= 0.01 + eplson))
@@ -49,11 +49,11 @@ class TestLinearBuild(unittest.TestCase):
         risk_lbound[:-1] = risk_lbound[:-1] - risk_tolerance
         risk_ubound[:-1] = risk_ubound[:-1] + risk_tolerance
 
-        status, _, w = linear_build(self.er,
-                                    0.,
-                                    0.01,
-                                    self.risk_exp,
-                                    risk_target=(risk_lbound, risk_ubound))
+        status, _, w = linear_builder(self.er,
+                                      0.,
+                                      0.01,
+                                      self.risk_exp,
+                                      risk_target=(risk_lbound, risk_ubound))
         self.assertEqual(status, 'optimal')
         self.assertAlmostEqual(np.sum(w), 1.)
         self.assertTrue(np.all(w <= 0.01 + eplson))
@@ -75,13 +75,13 @@ class TestLinearBuild(unittest.TestCase):
         risk_lbound[:-1] = risk_lbound[:-1] - risk_tolerance
         risk_ubound[:-1] = risk_ubound[:-1] + risk_tolerance
 
-        status, _, w = linear_build(self.er,
-                                    0.,
-                                    0.01,
-                                    self.risk_exp,
-                                    risk_target=(risk_lbound, risk_ubound),
-                                    turn_over_target=turn_over_target,
-                                    current_position=self.current_pos)
+        status, _, w = linear_builder(self.er,
+                                      0.,
+                                      0.01,
+                                      self.risk_exp,
+                                      risk_target=(risk_lbound, risk_ubound),
+                                      turn_over_target=turn_over_target,
+                                      current_position=self.current_pos)
         self.assertEqual(status, 'optimal')
         self.assertAlmostEqual(np.sum(w), 1.)
         self.assertTrue(np.all(w <= 0.01 + eplson))