Metadata-Version: 2.1
Name: opfunu
Version: 0.6.3
Summary: A framework of un-constrained Optimization Functions in Numpy (OpFuNu) for global optimization problems
Home-page: https://github.com/thieunguyen5991/opfunu
Author: Thieu Nguyen
Author-email: nguyenthieu2102@gmail.com
License: MIT
Download-URL: https://github.com/thieunguyen5991/opfunu/archive/v0.6.3.zip
Description: # Optimization Function in Numpy (OpFuNu)
        [![GitHub release](https://img.shields.io/badge/release-0.6.3-yellow.svg)]()
        [![Wheel](https://img.shields.io/pypi/wheel/gensim.svg)](https://pypi.python.org/pypi/opfunu) 
        [![PyPI version](https://badge.fury.io/py/opfunu.svg)](https://badge.fury.io/py/opfunu)
        [![DOI version](https://zenodo.org/badge/DOI/10.5281/zenodo.3620960.svg)](https://badge.fury.io/py/opfunu)
        [![License](https://img.shields.io/packagist/l/doctrine/orm.svg)]()
        
        ## Installation
        
        Install the [current PyPI release](https://pypi.python.org/pypi/opfunu):
        
        ```bash
        pip install opfunu
        ```
        
        Or install the development version from GitHub:
        
        ```bash
        pip install git+https://github.com/thieunguyen5991/opfunu
        ```
        
        
        ## Example
        + All you need to do is: (Make sure your solution is a numpy 1-D array)
        ```python 
        ## For dimension_based
        
        from opfunu.dimension_based.benchmark2d import Functions        # import 2-d benchmark functions
        import numpy as np
        
        solution2d = np.array([-0.1, 1.5])                              # Solution for 2-d benchmark
        func2d = Functions()                                            # create an object
        
        print(func2d._bartels_conn__(solution2d))                       # using function in above object
        print(func2d._bird__(solution2d))
        
        ## For type_based (same as dimension_based)
        
        from opfunu.type_based.multi_modal import Functions             # import 2-d benchmark functions
        import numpy as np
        
        
        ## For CEC
        
        from opfunu.cec.cec2014 import Functions                        # import cec2014 functions
        import numpy as np
        
        cec_sol = np.array([-0.1, 1.5])                              # Solution for 2-d benchmark
        cec_func = Functions()                                            # create an object
        
        print(cec_func.C1(cec_sol))                                  # using function in above object from C1, ..., C30
        print(cec_func.C30(cec_sol))
        
        
        ## CEC-2005 or CEC-2008
        
        import numpy as np
        from opfunu.cec.cec2005.F1 import Model as f1
        from opfunu.cec.cec2008.F7 import Model as f7
        
        solution = np.array([0.5, 1, 1.5, 2, 3, 0.9, 1.2, 2, 1, 5])
        
        t1 = f1()
        result = t1._main__(temp)
        print(result)
        
        t2 = f7()
        result = t2._main__(temp)
        print(result)
        
        
        
        ## CEC-2010 or CEC-2014
        
        import numpy as np
        from opfunu.cec.cec2010.function import F1, F2, ..., F12,..
        from opfunu.cec.cec2014.function import F1, F2, ...., F28
        
        solution = np.random.uniform(0, 1, 1000)
        result = F12(temp)
        print(result)
        
        
        ## CEC-2013 or CEC-2014 
        
        import numpy as np
        from opfunu.cec.cec2013.unconstraint import Model as M13
        from opfunu.cec.cec2014.unconstraint import Model as M14
        
        solution = np.random.uniform(0, 1, 10)
        
        result1 = M13(solution)
        print(result1.F1())
        
        result2 = M14(solution)
        print(result2.F1())
        
        ...
        ```
        
        ## References
        
        #### Publications
        + If you see my code and data useful and use it, please cites my works here
        ```code 
        @software{thieu_nguyen_2020_3711682,
          author       = {Thieu Nguyen},
          title        = {A framework of un-constrained Optimization Functions in Numpy (OpFuNu) for global optimization
         problems},
          month        = march,
          year         = 2020,
          publisher    = {Zenodo},
          doi          = {10.5281/zenodo.3620960},
          url          = {https://doi.org/10.5281/zenodo.3620960.}
        }
        
        @article{nguyen2019efficient,
          title={Efficient Time-Series Forecasting Using Neural Network and Opposition-Based Coral Reefs Optimization},
          author={Nguyen, Thieu and Nguyen, Tu and Nguyen, Binh Minh and Nguyen, Giang},
          journal={International Journal of Computational Intelligence Systems},
          volume={12},
          number={2},
          pages={1144--1161},
          year={2019},
          publisher={Atlantis Press}
        }
        ```
         
        + This project related to my another projects which are "meta-heuristics" and "neural-network", check it here
            + https://github.com/thieunguyen5991/metaheuristics
            + https://github.com/chasebk
            
        
        #### Documentation 
        ```code 
        1. dimension_based references
            1. http://benchmarkfcns.xyz/fcns
            2. https://en.wikipedia.org/wiki/Test_functions_for_optimization
            3. https://www.cs.unm.edu/~neal.holts/dga/benchmarkFunction/
            4. http://www.sfu.ca/~ssurjano/optimization.html
        
        2. type_based
            A Literature Survey of Benchmark Functions For Global Optimization Problems (2013)
        
        3. cec
            Problem Definitions and Evaluation Criteria for the CEC 2014 
        Special Session and Competition on Single Objective Real-Parameter Numerical Optimization 
        
        ```
        
Platform: UNKNOWN
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.7
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: Topic :: System :: Benchmark
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Intended Audience :: Science/Research
Requires-Python: >=3.7
Description-Content-Type: text/markdown
