便捷函数.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 2,
 "metadata": {
  "language_info": {
   "name": "python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   }
  },
  "orig_nbformat": 2,
  "file_extension": ".py",
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "cells": [
  {
   "cell_type": "markdown",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 便捷函数\n",
    "np.ployfit() # 用多项式去拟合一系列数据点,无论这些数据点是否来自连续  \n",
    "np.polyval() # 计算函数的值  \n",
    "np.roots() # 计算多项式函数什么时候到达0值  \n",
    "np.polyder() # 对多项式函数求导  \n",
    "np.sign()    # 函数可以返回数组中每个元素的正负符号  \n",
    "np.piecewise()  # 根据相关的条件，进行筛选  \n",
    "np.vectorize()  # 矢量化了一个函数  \n",
    "np.hanning()    # 平滑数据  \n",
    "np.polysub()    # 对多项式作差  \n",
    "np.isreal() # 判断数组元素是否为实数  \n",
    "np.select() # 根据一组给定的条件,从一组元素中挑选出符合条件的元素并返回数组  \n",
    ".real   # 返回实部  \n",
    "np.trim_zeros() # 去掉一维数组中开头和末尾为0的元素\n"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算函数\n",
    "np.cov()    # 协方差  \n",
    ".diagonal() # 查看对角线上的元素  \n",
    ".trace()    # 计算矩阵的迹   \n",
    "np.corrcoef()   ＃　计算相关系数（矩阵）  \n",
    "np.abs()    # 计算绝对值  \n",
    "round() # 方法返回浮点数x的四舍五入值  \n",
    ".sum()  # 数组中元素和　　"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "---\n",
    "# 动手实践"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from matplotlib.pyplot import plot\n",
    "from matplotlib.pyplot import show"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 股票相关性分析"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "bhp = np.loadtxt(\"/data/NumPy Learning/Code/ch4code/ch4code/BHP.csv\", delimiter=',', usecols=(6), unpack=True)\n",
    "bhp_return = np.diff(bhp) / bhp[:-1]\n",
    "\n",
    "vale = np.loadtxt(\"/data/NumPy Learning/Code/ch4code/ch4code/VALE.csv\", delimiter=',', usecols=(6), unpack=True)\n",
    "vale_return = np.diff(vale) / vale[:-1]\n",
    "\n",
    "covariance = np.cov(bhp_return, vale_return)\n",
    "print(\"Covariance\",covariance)\n",
    "\n",
    "print(\"Covariance diagonal\", covariance.diagonal())\n",
    "print(\"Covariance trace\", covariance.trace())\n",
    "print(\"Correlation coefficient\", np.corrcoef(bhp_return, vale_return))\n",
    "\n",
    "difference = bhp - vale\n",
    "avg = np.mean(difference)\n",
    "dev = np.std(difference)\n",
    "\n",
    "print(\"Out of sync\", np.abs(difference[-1] - avg) > 2 * dev)\n",
    "\n",
    "t = np.arange(len(bhp_return))\n",
    "plot(t, bhp_return, lw=1)\n",
    "plot(t, vale_return, lw=2)\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 多项式拟合\n",
    "np.ployfit(x,y,deg) 函数可以用多项式去拟合一系列数据点,无论这些数据点是否来自连续\n",
    "np.polyval(poly, x) 计算函数的值  \n",
    "np.roots(poly)  计算多项式函数什么时候到达0值  \n",
    "np.polyder(poly) 函数对多项式函数求导  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "bhp = np.loadtxt(\"/data/NumPy Learning/Code/ch4code/ch4code/BHP.csv\", delimiter=',', usecols=(6), unpack=True)\n",
    "vale = np.loadtxt(\"/data/NumPy Learning/Code/ch4code/ch4code/VALE.csv\", delimiter=',', usecols=(6), unpack=True)\n",
    "t = np.arange(len(bhp))\n",
    "\n",
    "poly = np.polyfit(t, bhp-vale, 5)\n",
    "print(\"Ploynomial fit\", poly)\n",
    "\n",
    "print(\"Next value\", np.polyval(ploy, t[-1]+1))\n",
    "print(\"Roots\", np.roots(poly))\n",
    "\n",
    "der = np.polyder(poly)\n",
    "print(\"Derivative\", der)\n",
    "\n",
    "#　求极值\n",
    "print(\"Extremas\", np.roots(der))\n",
    "\n",
    "# 拟合曲线\n",
    "vals = np.polyval(poly, t)\n",
    "plot(t, bhp - vale)\n",
    "plot(t, vals)\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 计算 OBV\n",
    "sign 函数可以返回数组中每个元素的正负符号,数组元素为负时返回 -1 ,为正时返回 1 ,否则返回 0  \n",
    "piecewise 根据相关的条件，进行筛选 获取数组元素的正负 可以分段给定取值  \n",
    "numpy.piecewise(x, condlist, funclist, *args, **kw)  \n",
    "x:表示要进行操作的对象  \n",
    "condlist，表示要满足的条件列表，可以是多个条件构成的列表  \n",
    "funclist，执行的操作列表，参数二与参数三是对应的，当参数二为true的时候，则执行相对应的操作函数。  \n",
    "np.array_equal() 比较两个数组的是否相等"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "c,v = np.loadtxt(\"/data/NumPy Learning/Code/ch4code/ch4code/BHP.csv\", delimiter=',', usecols=(6,7), unpack=True)\n",
    "change = np.diff(c)\n",
    "print(\"Change\", change)\n",
    "\n",
    "signs = np.sign(change)\n",
    "print(\"Signs\", signs)\n",
    "\n",
    "pieces = np.piecewise(change, [change<0,change>0], [-1,1])\n",
    "print(\"Pieces\", pieces)\n",
    "\n",
    "print(\"Arrays equal?\", np.array_equal(signs, pieces))\n",
    "\n",
    "print(\"On balance volume\", v[1:] * signs)"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 避免使用循环\n",
    "vectorize 矢量化了一个函数 可以减少程序中使用循环的次数  \n",
    "round() 方法返回浮点数x的四舍五入值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "o,h,l,c = np.loadtxt(\"/data/NumPy Learning/Code/ch4code/ch4code/BHP.csv\", delimiter=',', usecols=(3,4,5,6), unpack=True)\n",
    "\n",
    "def calc_profit(open, high, low, close):\n",
    "    # 在开盘时买入\n",
    "    buy = open * float(1.002)\n",
    "    # 当日股价区间\n",
    "    if low < buy < high:\n",
    "        return (close - buy)/buy\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "func = np.vectorize(calc_profit)\n",
    "profits = func(o, h, l, c)\n",
    "print(\"Profits\", profits)\n",
    "\n",
    "real_trades = profits[profits != 0]\n",
    "print(\"Number of trades\", len(real_trades), round(100.0 * len(real_trades)/len(c),2), \"%\")\n",
    "print(\"Average profit/loss %\", round(np.mean(real_trades) * 100, 2))\n",
    "\n",
    "winning_trades = profits[profits > 0]\n",
    "print(\"Number of winning trades\", len(winning_trades), round(100.0 *\n",
    "len(winning_trades)/len(c), 2), \"%\")\n",
    "print(\"Average profit %\", round(np.mean(winning_trades) * 100, 2))\n",
    "losing_trades = profits[profits < 0]\n",
    "print(\"Number of losing trades\", len(losing_trades), round(100.0 *\n",
    "len(losing_trades)/len(c), 2), \"%\")\n",
    "print(\"Average loss %\", round(np.mean(losing_trades) * 100, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 数据平滑\n",
    "使用 hanning 函数平滑数据  \n",
    "polysub 函数对多项式作差  \n",
    "isreal 函数来判断数组元素是否为实数  \n",
    "select 函数可以根据一组给定的条件,从一组元素中挑选出符合条件的元素并返回数组  \n",
    ".real   返回实部  \n",
    "trim_zeros 函数可以去掉一维数组中开头和末尾为0的元素  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 8\n",
    "# 调用hanning函数计算权重,生成一个长度为N的窗口\n",
    "weights = np.hanning(N)\n",
    "print(\"Weights\", weights)\n",
    "\n",
    "bhp = np.loadtxt(\"/data/NumPy Learning/Code/ch4code/ch4code/BHP.csv\", delimiter=',', usecols=(6), unpack=True)\n",
    "bhp_returns = np.diff(bhp) / bhp[ : -1]\n",
    "# .sum(axis) # 数组中元素和\n",
    "smooth_bhp = np.convolve(weights/weights.sum(), bhp_returns) [N-1:-N+1]\n",
    "\n",
    "vale = np.loadtxt(\"/data/NumPy Learning/Code/ch4code/ch4code/VALE.csv\", delimiter=',', usecols=(6), unpack=True)\n",
    "vale_returns = np.diff(vale) / vale[ : -1]\n",
    "smooth_vale = np.convolve(weights/weights.sum(), vale_returns) [N-1:-N+1]\n",
    "\n",
    "t = np.arange(N - 1, len(bhp_returns))\n",
    "plot(t, bhp_returns[N-1:], lw=1.0)\n",
    "plot(t, smooth_bhp, lw=2.0)\n",
    "plot(t, vale_returns[N-1:], lw=1.0)\n",
    "plot(t, smooth_vale, lw=2.0)\n",
    "show()\n",
    "\n",
    "# 使用多项式拟合平滑后的数据\n",
    "K = 8\n",
    "t = np.arange(N - 1, len(bhp_returns))\n",
    "poly_bhp = np.polyfit(t, smooth_bhp, K)\n",
    "poly_vale = np.polyfit(t, smooth_vale, K)\n",
    "\n",
    "poly_sub = np.polysub(poly_bhp, poly_vale)\n",
    "xpoints = np.roots(poly_sub)\n",
    "print(\"Intersection points\", xpoints)\n",
    "\n",
    "reals = np.isreal(xpoints)\n",
    "print(\"Real number?\", reals)\n",
    "\n",
    "xpoints = np.select([reals], [xpoints])\n",
    "xpoints = xpoints.real\n",
    "print(\"Real intersection points\", xpoints)\n",
    "print(\"Sans 0s\", np.trim_zeros(xpoints))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}