zoukankan      html  css  js  c++  java
  • 量化编程技术—数学最优解

    from abc import ABCMeta, abstractmethod
    import six
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    
    # 每个人平均寿命期望是75年,约75*365=27375天
    K_INIT_LIVING_DAYS = 27375
    
    class Person(object):
        """
            人类
        """
    
        def __init__(self):
            # 初始化人平均能活的寿命
            self.living = K_INIT_LIVING_DAYS
            # 初始化幸福指数
            self.happiness = 0
            # 初始化财富值
            self.wealth = 0
            # 初始化名望权利
            self.fame = 0
            # 活着的第几天
            self.living_day = 0
    
        def live_one_day(self, seek):
            """
            每天只能进行一个seek,这个seek决定了你今天追求的是什么,得到了什么
            seek的类型属于下面将编写的BaseSeekDay
            :param seek:
            :return:
            """
            # 调用每个独特的BaseSeekDay类都会实现的do_seek_day,得到今天的收获
            consume_living, happiness, wealth, fame = seek.do_seek_day()
            # 每天要减去生命消耗,有些seek前面还会增加生命
            self.living -= consume_living
            # seek得到的幸福指数积累
            self.happiness += happiness
            # seek得到的财富积累
            self.wealth += wealth
            # seek得到的名望权力积累
            self.fame += fame
            # 活完这一天了
            self.living_day += 1
    
    
    class BaseSeekDay(six.with_metaclass(ABCMeta, object)):
        def __init__(self):
            # 每个追求每天消耗生命的常数
            self.living_consume = 0
    
            # 每个追求每天幸福指数常数
            self.happiness_base = 0
    
            # 每个追求每天财富积累常数
            self.wealth_base = 0
            # 每个追求每天名望权利积累常数
            self.fame_base = 0
    
            # 每个追求每天消耗生命的可变因素序列
            self.living_factor = [0]
    
            # 每个追求每天幸福指数的可变因素序列
            self.happiness_factor = [0]
    
            # 每个追求每天财富积累的可变因素序列
            self.wealth_factor = [0]
            # 每个追求每天名望权利的可变因素序列
            self.fame_factor = [0]
    
            # 追求了多少天了这一生
            self.do_seek_day_cnt = 0
            # 子类进行常数及可变因素序列设置
            self._init_self()
    
        @abstractmethod
        def _init_self(self, *args, **kwargs):
            # 子类必须实现,设置自己的生命消耗的常数,幸福指数常数等常数设置
            pass
    
        @abstractmethod
        def _gen_living_days(self, *args, **kwargs):
            # 子类必须实现,设置自己的可变因素序列
            pass
    
        def do_seek_day(self):
            """
            每一天的追求具体seek
            :return:
            """
            # 生命消耗=living_consume:消耗常数 * happiness_factor:可变序列
            if self.do_seek_day_cnt >= len(self.living_factor):
                # 超出len(self.living_factor), 就取最后一个living_factor[-1]
                consume_living = 
                    self.living_factor[-1] * self.living_consume
            else:
                # 每个类自定义这个追求的消耗生命常数,以及living_factor,比如
                # HealthSeekDay追求健康,living_factor序列的值即由负值->正值
                # 每个子类living_factor会有自己特点的变化速度及序列长度,导致每个
                # 追求对生命的消耗随着追求的次数变化不一
                consume_living = self.living_factor[self.do_seek_day_cnt] 
                                 * self.living_consume
            # 幸福指数=happiness_base:幸福常数 * happiness_factor:可变序列
            if self.do_seek_day_cnt >= len(self.happiness_factor):
                # 超出len(self.happiness_factor), 就取最后一个
                # 由于happiness_factor值由:n—>0 所以happiness_factor[-1]=0
                # 即随着追求一个事物的次数过多后会变的没有幸福感
                happiness = self.happiness_factor[
                                -1] * self.happiness_base
            else:
                # 每个类自定义这个追求的幸福指数常数,以及happiness_factor
                # happiness_factor子类的定义一般是从高->低变化
                happiness = self.happiness_factor[
                                self.do_seek_day_cnt] * self.happiness_base
            # 财富积累=wealth_base:积累常数 * wealth_factor:可变序列
            if self.do_seek_day_cnt >= len(self.wealth_factor):
                # 超出len(self.wealth_factor), 就取最后一个
                wealth = self.wealth_factor[-1] * self.wealth_base
            else:
                # 每个类自定义这个追求的财富指数常数,以及wealth_factor
                wealth = self.wealth_factor[
                             self.do_seek_day_cnt] * self.wealth_base
            # 权利积累=fame_base:积累常数 * fame_factor:可变序列
            if self.do_seek_day_cnt >= len(self.fame_factor):
                # 超出len(self.fame_factor), 就取最后一个
                fame = self.fame_factor[-1] * self.fame_base
            else:
                # 每个类自定义这个追求的名望权利指数常数,以及fame_factor
                fame = self.fame_factor[
                           self.do_seek_day_cnt] * self.fame_base
            # 追求了多少天了这一生 + 1
            self.do_seek_day_cnt += 1
            # 返回这个追求这一天对生命的消耗,得到的幸福,财富,名望权利
            return consume_living, happiness, wealth, fame
            
            
    def regular_mm(group):
        # 最小-最大规范化
        return (group - group.min()) / (group.max() - group.min())
    
    
    class HealthSeekDay(BaseSeekDay):
        """
            HealthSeekDay追求健康长寿的一天:
            形象:健身,旅游,娱乐,做感兴趣的事情。
            抽象:追求健康长寿。
        """
    
        def _init_self(self):
            # 每天对生命消耗的常数=1,即代表1天
            self.living_consume = 1
            # 每天幸福指数常数=1
            self.happiness_base = 1
            # 设定可变因素序列
            self._gen_living_days()
    
        def _gen_living_days(self):
            # 只生成12000个序列,因为下面的happiness_factor序列值由1->0
            # 所以大于12000次的追求都将只是单纯消耗生命,并不增加幸福指数
            # 即随着做一件事情的次数越来越多,幸福感越来越低,直到完全体会不到幸福
            days = np.arange(1, 12000)
            # 基础函数选用sqrt, 影响序列变化速度
            living_days = np.sqrt(days)
    
            """
                对生命消耗可变因素序列值由-1->1, 也就是这个追求一开始的时候对生命
                的消耗为负增长,延长了生命,随着追求的次数不断增多对生命的消耗转为正
                数因为即使一个人天天锻炼身体,天天吃营养品,也还是会有自然死亡的那
                一天
            """
            # *2-1的目的:regular_mm在0-1之间,HealthSeekDay要结果在-1,1之间
            self.living_factor = regular_mm(living_days) * 2 - 1
            # 结果在1-0之间 [::-1]: 将0->1转换到1->0
            self.happiness_factor = regular_mm(days)[::-1]
            
            
    # 初始化我, 你一生的故事:HealthSeekDay
    me = Person()
    # 初始化追求健康长寿快乐
    seek_health = HealthSeekDay()
    while me.living > 0:
        # 只要还活着,就追求健康长寿快乐
        me.live_one_day(seek_health)
    
    print('只追求健康长寿快乐活了{}年,幸福指数{},积累财富{},名望权力{}'.format
          (round(me.living_day / 365, 2), round(me.happiness, 2),
           me.wealth, me.fame))
           
           
    plt.plot(seek_health.living_factor * seek_health.living_consume)
    plt.plot(seek_health.happiness_factor * seek_health.happiness_base)
    plt.legend(['living_factor', 'happiness_factor'], loc='best')
  • 相关阅读:
    MySQL学习笔记
    为什么使用多态?实现多态的有哪些方式
    C++中派生类使用基类成员的问题
    实现Modbus ASCII多主站应用
    PHP第四天 函数引用传值
    Webpack 快速上手(下)
    Java---23种设计模式(九)------组合模式
    【笔记】Linux就该这么学-第六课第四章
    Node.js HTTPS
    Node.js Smalloc
  • 原文地址:https://www.cnblogs.com/bitquant/p/11521580.html
Copyright © 2011-2022 走看看